def new(self, errors={}):
self._disable_cache()
if not has.dataset.create():
return templating.render('dataset/new_cta.html')
require.dataset.create()
c.key_currencies = sorted([(r, n) for (r, (n, k)) in CURRENCIES.items() if k],
key=lambda (k, v): v)
c.all_currencies = sorted([(r, n) for (r, (n, k)) in CURRENCIES.items() if not k],
key=lambda (k, v): v)
c.languages = sorted(LANGUAGES.items(), key=lambda (k, v): v)
c.territories = sorted(COUNTRIES.items(), key=lambda (k, v): v)
c.categories = sorted(CATEGORIES.items(), key=lambda (k, v): v)
errors = [(k[len('dataset.'):], v) for k, v in errors.items()]
return templating.render('dataset/new.html', form_errors=dict(errors),
form_fill=request.params if errors else {'currency': 'USD'})
def member(self, dataset, dimension, name, format="html"):
self._get_member(dataset, dimension, name)
handle_request(request, c, c.member, c.dimension.name)
member = [member_apply_links(dataset, dimension, c.member)]
if format == 'json':
return write_json(member, response)
elif format == 'csv':
return write_csv(member, response)
else:
# If there are no views set up, then go direct to the entries
# search page
if c.view is None:
return redirect(
url_for(controller='dimension',
action='entries',
dataset=c.dataset.name,
dimension=dimension,
name=name))
if 'embed' in request.params:
return redirect(
url_for(controller='view',
action='embed',
dataset=c.dataset.name,
widget=c.view.vis_widget.get('name'),
state=json.dumps(c.view.vis_state)))
return templating.render('dimension/member.html')
def about(self, dataset, format='html'):
self._get_dataset(dataset)
etag_cache_keygen(c.dataset.updated_at)
handle_request(request, c, c.dataset)
c.sources = list(c.dataset.sources)
c.managers = list(c.dataset.managers)
return templating.render('dataset/about.html')
def new(self, dataset, errors={}):
self._get_dataset(dataset)
require.dataset.update(c.dataset)
params_dict = dict(request.params) if errors else {}
return templating.render('source/new.html',
form_errors=errors,
form_fill=params_dict)
def index(self):
# Get all of the datasets available to the account of the logged in
# or an anonymous user (if c.account is None)
c.datasets = Dataset.all_by_account(c.account)
c.num_entries = dataset_entries(None)
return templating.render('home/index.html')
def index(self, dataset, format='html'):
# Get the dataset into the context variable 'c'
self._get_dataset(dataset)
# If the format is either json or csv we direct the user to the search
# API instead
if format in ['json', 'csv']:
return redirect(h.url_for(controller='api/version2',
action='search',
format=format, dataset=dataset,
**request.params))
# Get the default view
handle_request(request, c, c.dataset)
# Parse the parameters using the SearchParamParser (used by the API)
parser = EntryIndexParamParser(request.params)
params, errors = parser.parse()
# We have to remove page from the parameters because that's also
# used in the Solr browser (which fetches the queries)
params.pop('page')
# We limit ourselve to only our dataset
params['filter']['dataset'] = [c.dataset.name]
facet_dimensions = {field.name: field
for field in c.dataset.dimensions
if field.facet}
params['facet_field'] = facet_dimensions.keys()
# Create a Solr browser and execute it
b = Browser(**params)
try:
b.execute()
except SolrException as e:
return {'errors': [unicode(e)]}
# Get the entries, each item is a tuple of the dataset and entry
solr_entries = b.get_entries()
entries = [entry for (dataset, entry) in solr_entries]
# Get expanded facets for this dataset,
c.facets = b.get_expanded_facets(c.dataset)
# Create a pager for the entries
c.entries = templating.Page(entries, **request.params)
# Set the search word and default to empty string
c.search = params.get('q', '')
# Set filters (but remove the dataset as we don't need it)
c.filters = params['filter']
del c.filters['dataset']
# We also make the facet dimensions and dimension names available
c.facet_dimensions = facet_dimensions
c.dimensions = [dimension.name for dimension in c.dataset.dimensions]
# Render the entries page
return templating.render('entry/index.html')
def member(self, dataset, dimension, name, format="html"):
self._get_member(dataset, dimension, name)
handle_request(request, c, c.member, c.dimension.name)
member = [member_apply_links(dataset, dimension, c.member)]
if format == "json":
return write_json(member, response)
elif format == "csv":
return write_csv(member, response)
else:
# If there are no views set up, then go direct to the entries
# search page
if c.view is None:
return redirect(
url_for(
controller="dimension", action="entries", dataset=c.dataset.name, dimension=dimension, name=name
)
)
if "embed" in request.params:
return redirect(
url_for(
controller="view",
action="embed",
dataset=c.dataset.name,
widget=c.view.vis_widget.get("name"),
state=json.dumps(c.view.vis_state),
)
)
return templating.render("dimension/member.html")
def document(self):
"""Render the error document - show custom template for 404"""
self._disable_cache()
resp = request.environ.get('pylons.original_response')
# Don't do fancy error documents for JSON
if resp.headers['Content-Type'] in [
'text/javascript', 'application/json', 'text/csv'
]:
response.headers['Content-Type'] = resp.headers['Content-Type']
return resp.body
code = cgi.escape(request.GET.get('code', str(resp.status_int)))
content = (literal(resp.body)
or cgi.escape(request.GET.get('message', '')))
if code in self.rendered_error_codes:
c.code = code
message = content
message = message.split('</h1>', 1)[-1]
message = message.split('</body>', 1)[0]
c.message = message.split('\n', 2)[-1]
return templating.render('errors/%s.html' % code)
else:
page = error_document_template % \
dict(prefix=request.environ.get('SCRIPT_NAME', ''),
code=code,
message=content)
return page
def view(self, dataset, id, format='html'):
self._get_dataset(dataset)
entries = list(c.dataset.entries(c.dataset.alias.c.id == id))
if not len(entries) == 1:
abort(404, _('Sorry, there is no entry %r') % id)
c.entry = entry_apply_links(dataset, entries.pop())
c.id = c.entry.get('id')
c.from_ = c.entry.get('from')
c.to = c.entry.get('to')
c.currency = c.entry.get('currency', c.dataset.currency).upper()
c.amount = c.entry.get('amount')
c.time = c.entry.get('time')
c.custom_html = h.render_entry_custom_html(c.dataset,
c.entry)
excluded_keys = ('time', 'amount', 'currency', 'from',
'to', 'dataset', 'id', 'name', 'description')
c.extras = {}
if c.dataset:
c.desc = dict([(d.name, d) for d in c.dataset.dimensions])
for key in c.entry:
if key in c.desc and \
not key in excluded_keys:
c.extras[key] = c.entry[key]
if format == 'json':
return to_jsonp(c.entry)
elif format == 'csv':
return write_csv([c.entry], response)
else:
return templating.render('entry/view.html')
def document(self):
"""Render the error document - show custom template for 404"""
self._disable_cache()
resp = request.environ.get('pylons.original_response')
# Don't do fancy error documents for JSON
if resp.headers['Content-Type'] in ['text/javascript', 'application/json', 'text/csv']:
response.headers['Content-Type'] = resp.headers['Content-Type']
return resp.body
code = cgi.escape(request.GET.get('code', str(resp.status_int)))
content = (literal(resp.body) or
cgi.escape(request.GET.get('message', '')))
if code in self.rendered_error_codes:
c.code = code
message = content
message = message.split('</h1>', 1)[-1]
message = message.split('</body>', 1)[0]
c.message = message.split('\n', 2)[-1]
return templating.render('errors/%s.html' % code)
else:
page = error_document_template % \
dict(prefix=request.environ.get('SCRIPT_NAME', ''),
code=code,
message=content)
return page
def profile(self, name=None):
"""
Generate a profile page for a user (from the provided name)
"""
# Get the account, if it's none we return a 404
account = Account.by_name(name)
if account is None:
response.status = 404
return None
# Set the account we got as the context variable 'profile'
# Note this is not the same as the context variable 'account'
# which is the account for a logged in user
c.profile = account
# Set a context boo if email/twitter should be shown, it is only shown
# to administrators and to owner (account is same as context account)
show_info = (c.account and c.account.admin) or (c.account == account)
# ..or if the user has chosen to make it public
c.show_email = show_info or account.public_email
c.show_twitter = show_info or account.public_twitter
# Collect and sort the account's datasets and views
c.account_datasets = sorted(account.datasets, key=lambda d: d.label)
c.account_views = sorted(account.views, key=lambda d: d.label)
# Render the profile
return templating.render('account/profile.html')
def view(self, dataset, id, format='html'):
self._get_dataset(dataset)
entries = list(c.dataset.entries(c.dataset.alias.c.id == id))
if not len(entries) == 1:
abort(404, _('Sorry, there is no entry %r') % id)
c.entry = entry_apply_links(dataset, entries.pop())
c.id = c.entry.get('id')
c.from_ = c.entry.get('from')
c.to = c.entry.get('to')
c.currency = c.entry.get('currency', c.dataset.currency).upper()
c.amount = c.entry.get('amount')
c.time = c.entry.get('time')
c.custom_html = h.render_entry_custom_html(c.dataset, c.entry)
excluded_keys = ('time', 'amount', 'currency', 'from', 'to', 'dataset',
'id', 'name', 'description')
c.extras = {}
if c.dataset:
c.desc = dict([(d.name, d) for d in c.dataset.dimensions])
for key in c.entry:
if key in c.desc and \
not key in excluded_keys:
c.extras[key] = c.entry[key]
if format == 'json':
return to_jsonp(c.entry)
elif format == 'csv':
return write_csv([c.entry], response)
else:
return templating.render('entry/view.html')
def profile(self, name=None):
"""
Generate a profile page for a user (from the provided name)
"""
# Get the account, if it's none we return a 404
account = Account.by_name(name)
if account is None:
response.status = 404
return None
# Set the account we got as the context variable 'profile'
# Note this is not the same as the context variable 'account'
# which is the account for a logged in user
c.profile = account
# Set a context boo if email/twitter should be shown, it is only shown
# to administrators and to owner (account is same as context account)
show_info = (c.account and c.account.admin) or (c.account == account)
# ..or if the user has chosen to make it public
c.show_email = show_info or account.public_email
c.show_twitter = show_info or account.public_twitter
# Collect and sort the account's datasets and views
c.account_datasets = sorted(account.datasets, key=lambda d: d.label)
c.account_views = sorted(account.views, key=lambda d: d.label)
# Render the profile
return templating.render('account/profile.html')
def core_edit(self, dataset, errors={}, format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
c.key_currencies = sorted(
[(r, n) for (r, (n, k)) in CURRENCIES.items() if k],
key=lambda k_v: k_v[1])
c.all_currencies = sorted(
[(r, n) for (r, (n, k)) in CURRENCIES.items() if not k],
key=lambda k_v1: k_v1[1])
c.languages = sorted(LANGUAGES.items(), key=lambda k_v2: k_v2[1])
c.territories = sorted(COUNTRIES.items(), key=lambda k_v3: k_v3[1])
c.categories = sorted(CATEGORIES.items(), key=lambda k_v4: k_v4[1])
if 'time' in c.dataset:
c.available_times = [m['year']
for m in c.dataset['time'].members()]
c.available_times = sorted(set(c.available_times), reverse=True)
else:
c.available_times = []
errors = [(k[len('dataset.'):], v) for k, v in errors.items()]
fill = c.dataset.as_dict()
if errors:
fill.update(request.params)
return templating.render('editor/core.html', form_errors=dict(errors),
form_fill=fill)
def team_edit(self, dataset, errors={}, accounts=None, format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
accounts = accounts or c.dataset.managers
c.accounts = json.dumps([a.as_dict() for a in accounts], indent=2)
c.errors = errors
return templating.render('editor/team.html')
def views_edit(self, dataset, errors={}, views=None, format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
views = views or c.dataset.data.get('views', [])
c.fill = {'views': json.dumps(views, indent=2)}
c.errors = errors
return templating.render('editor/views.html', form_fill=c.fill)
def index(self, dataset, format='html'):
self._get_dataset(dataset)
handle_request(request, c, c.dataset)
c.views = View.all_by_dataset(c.dataset)
if format == 'json':
return to_jsonp([v.as_dict() for v in c.views])
else:
return templating.render('view/index.html')
def view(self, dataset, name, format='html'):
self._get_named_view(dataset, name)
handle_request(request, c, c.dataset)
c.widget = widgets.get_widget(c.named_view.widget)
if format == 'json':
return to_jsonp(c.named_view.as_dict())
else:
return templating.render('view/view.html')
def index(self, dataset, format='html'):
self._get_dataset(dataset)
handle_request(request, c, c.dataset)
c.views = View.all_by_dataset(c.dataset)
if format == 'json':
return to_jsonp([v.as_dict() for v in c.views])
else:
return templating.render('view/index.html')
def view(self, section, path):
c.resource = ContentResource(section, path)
c.content_section = section
if not c.resource.exists():
abort(404, _("Sorry, the selected resource could not be found"))
if not c.resource.is_html():
redirect(c.resource.url, code=301)
return templating.render("content/view.html")
def index(self, dataset, format="html"):
self._get_dataset(dataset)
etag_cache_keygen(c.dataset.updated_at, format)
if format == "json":
dimensions = [dimension_apply_links(dataset, d.as_dict()) for d in c.dataset.dimensions]
return to_jsonp(dimensions)
else:
return templating.render("dimension/index.html")
def view(self, section, path):
c.resource = ContentResource(section, path)
c.content_section = section
if not c.resource.exists():
abort(404, _("Sorry, the selected resource could not be found"))
if not c.resource.is_html():
redirect(c.resource.url, code=301)
return templating.render('content/view.html')
def view(self, dataset, name, format='html'):
self._get_named_view(dataset, name)
handle_request(request, c, c.dataset)
c.widget = widgets.get_widget(c.named_view.widget)
if format == 'json':
return to_jsonp(c.named_view.as_dict())
else:
return templating.render('view/view.html')
def index(self):
# Get all of the datasets available to the account of the logged in
# or an anonymous user (if c.account is None)
c.datasets = Dataset.all_by_account(c.account)
c.territories = DatasetTerritory.dataset_counts(c.datasets)
c.num_entries = dataset_entries(None)
return templating.render('home/index.html')
def templates_edit(self, dataset, errors={}, values=None,
format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
c.fill = values or {'serp_title': c.dataset.serp_title,
'serp_teaser': c.dataset.serp_teaser}
c.errors = errors
return templating.render('editor/templates.html', form_fill=c.fill)
def view(self, dataset, dimension, format="html"):
self._get_dimension(dataset, dimension)
etag_cache_keygen(c.dataset.updated_at, format)
if format == "json":
dimension = dimension_apply_links(dataset, c.dimension.as_dict())
return to_jsonp(dimension)
c.widget = get_widget("aggregate_table")
c.widget_state = {"drilldowns": [c.dimension.name]}
return templating.render("dimension/view.html")
def index(self, dataset, format='html'):
self._get_dataset(dataset)
etag_cache_keygen(c.dataset.updated_at, format)
if format == 'json':
dimensions = [dimension_apply_links(dataset, d.as_dict()) \
for d in c.dataset.dimensions]
return to_jsonp(dimensions)
else:
return templating.render('dimension/index.html')
def view(self, dataset, dimension, format='html'):
self._get_dimension(dataset, dimension)
etag_cache_keygen(c.dataset.updated_at, format)
if format == 'json':
dimension = dimension_apply_links(dataset, c.dimension.as_dict())
return to_jsonp(dimension)
c.widget = get_widget('aggregate_table')
c.widget_state = {'drilldowns': [c.dimension.name]}
return templating.render('dimension/view.html')
def views_edit(self, dataset, errors={}, views=None,
format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
views = views or c.dataset.data.get('views', [])
c.fill = {'views': json.dumps(views, indent=2)}
c.errors = errors
return templating.render('editor/views.html', form_fill=c.fill)
def templates_edit(self, dataset, errors={}, values=None,
format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
c.fill = values or {'serp_title': c.dataset.serp_title,
'serp_teaser': c.dataset.serp_teaser}
c.errors = errors
return templating.render('editor/templates.html', form_fill=c.fill)
def new(self, errors={}):
self._disable_cache()
if not has.dataset.create():
return templating.render('dataset/new_cta.html')
require.dataset.create()
c.key_currencies = sorted(
[(r, n) for (r, (n, k)) in CURRENCIES.items() if k],
key=lambda k_v: k_v[1])
c.all_currencies = sorted(
[(r, n) for (r, (n, k)) in CURRENCIES.items() if not k],
key=lambda k_v1: k_v1[1])
c.languages = sorted(LANGUAGES.items(), key=lambda k_v2: k_v2[1])
c.territories = sorted(COUNTRIES.items(), key=lambda k_v3: k_v3[1])
c.categories = sorted(CATEGORIES.items(), key=lambda k_v4: k_v4[1])
errors = [(k[len('dataset.'):], v) for k, v in errors.items()]
return templating.render(
'dataset/new.html', form_errors=dict(errors),
form_fill=request.params if errors else {'currency': 'USD'})
def view(self, dataset, dimension, format='html'):
self._get_dimension(dataset, dimension)
etag_cache_keygen(c.dataset.updated_at, format)
if format == 'json':
dimension = dimension_apply_links(dataset, c.dimension.as_dict())
return to_jsonp(dimension)
c.widget = get_widget('aggregate_table')
c.widget_state = {'drilldowns': [c.dimension.name]}
return templating.render('dimension/view.html')
def team_edit(self, dataset, errors={}, accounts=None,
format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
accounts = accounts or c.dataset.managers
c.accounts = json.dumps([a.as_dict() for a in accounts], indent=2)
c.errors = errors
return templating.render('editor/team.html')
def index(self, dataset, format='html'):
self._get_dataset(dataset)
if format in ['json', 'csv']:
return redirect(h.url_for(controller='api2', action='search',
format=format, dataset=dataset,
**request.params))
handle_request(request, c, c.dataset)
return templating.render('entry/index.html')
def dimensions_edit(self, dataset, errors={}, mapping=None,
format='html', saved=False):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
# TODO: really split up dimensions and mapping editor.
c.source = c.dataset.sources.first()
if c.source is None:
return templating.render('editor/dimensions_errors.html')
mapping = mapping or c.dataset.data.get('mapping', {})
if not len(mapping) and c.source and 'mapping' in c.source.analysis:
mapping = c.source.analysis['mapping']
c.fill = {'mapping': json.dumps(mapping, indent=2)}
c.errors = errors
c.saved = saved
if len(c.dataset):
return templating.render('editor/dimensions_errors.html')
return templating.render('editor/dimensions.html', form_fill=c.fill)
def index(self):
dataset = db.session.query(Dataset).filter_by(private=False).first()
entry = list(dataset.entries(limit=1)).pop()
c.urls = [
url(controller='dataset', action='view', dataset=dataset.name,
format='json'),
url(controller='entry', action='view', dataset=dataset.name,
id=entry['id'], format='json')]
return templating.render('home/rest.html')
def dimensions_edit(self, dataset, errors={}, mapping=None,
format='html', saved=False):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
# TODO: really split up dimensions and mapping editor.
c.source = c.dataset.sources.first()
if c.source is None:
return templating.render('editor/dimensions_errors.html')
mapping = mapping or c.dataset.data.get('mapping', {})
if not len(mapping) and c.source and 'mapping' in c.source.analysis:
mapping = c.source.analysis['mapping']
c.fill = {'mapping': json.dumps(mapping, indent=2)}
c.errors = errors
c.saved = saved
if len(c.dataset):
return templating.render('editor/dimensions_errors.html')
return templating.render('editor/dimensions.html', form_fill=c.fill)
def index(self, dataset, format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
c.entries_count = len(c.dataset)
c.has_sources = c.dataset.sources.count() > 0
c.source = c.dataset.sources.first()
c.index_count = solr.dataset_entries(c.dataset.name)
c.index_percentage = 0 if not c.entries_count else \
int((float(c.index_count) / float(c.entries_count)) * 1000)
return templating.render('editor/index.html')
def embed(self, dataset):
self._get_dataset(dataset)
c.widget = request.params.get('widget')
if c.widget is None:
abort(400, _("No widget type has been specified."))
try:
c.widget = widgets.get_widget(c.widget)
c.state = json.loads(request.params.get('state', '{}'))
except ValueError as ve:
abort(400, unicode(ve))
return templating.render('view/embed.html')
def embed(self, dataset):
self._get_dataset(dataset)
c.widget = request.params.get('widget')
if c.widget is None:
abort(400, _("No widget type has been specified."))
try:
c.widget = widgets.get_widget(c.widget)
c.state = json.loads(request.params.get('state', '{}'))
except ValueError as ve:
abort(400, unicode(ve))
return templating.render('view/embed.html')
def index(self, dataset, format='html'):
self._get_dataset(dataset)
self._disable_cache()
require.dataset.update(c.dataset)
c.entries_count = len(c.dataset)
c.has_sources = c.dataset.sources.count() > 0
c.source = c.dataset.sources.first()
c.index_count = solr.dataset_entries(c.dataset.name)
c.index_percentage = 0 if not c.entries_count else \
int((float(c.index_count) / float(c.entries_count)) * 1000)
return templating.render('editor/index.html')
def entries(self, dataset, dimension, name, format='html'):
self._get_member(dataset, dimension, name)
if format in ['json', 'csv']:
return redirect(url_for(controller='api/version2', action='search',
format=format, dataset=dataset,
filter='%s.name:%s' % (dimension, name),
**request.params))
handle_request(request, c, c.member, c.dimension.name)
entries = c.dataset.entries(c.dimension.alias.c.name == c.member['name'])
entries = (entry_apply_links(dataset, e) for e in entries)
return templating.render('dimension/entries.html')
def new(self, dataset, errors={}):
self._get_dataset(dataset)
self._disable_cache()
handle_request(request, c, c.dataset)
c.widgets = dict([(n, widgets.get_widget(n)) \
for n in widgets.list_widgets()])
if 'dev_widget' in request.params and \
request.params.get('dev_widget') not in widgets.list_widgets():
n = request.params.get('dev_widget')
c.widgets[n] = widgets.get_widget(n, force=True)
c.errors = errors
c.can_save = can.view.create(c.dataset)
return templating.render('view/new.html')
def login(self):
"""
Render the login page (which is also the registration page)
"""
# Disable cache
self._disable_cache()
# Add config (so we can offer users to subscribe to mailing lists)
c.config = config
# Return the rendered template
return templating.render('account/login.html')
def login(self):
"""
Render the login page (which is also the registration page)
"""
# Disable cache
self._disable_cache()
# Add config (so we can offer users to subscribe to mailing lists)
c.config = config
# Return the rendered template
return templating.render('account/login.html')
def about(self, dataset, format='html'):
self._get_dataset(dataset)
etag_cache_keygen(c.dataset.updated_at)
handle_request(request, c, c.dataset)
c.sources = list(c.dataset.sources)
c.managers = list(c.dataset.managers)
# Get all badges if user is admin because they can then
# give badges to the dataset on its about page.
if c.account and c.account.admin:
c.badges = list(Badge.all())
return templating.render('dataset/about.html')
def index(self, dataset, format='html'):
self._get_dataset(dataset)
if format in ['json', 'csv']:
return redirect(
h.url_for(controller='api2',
action='search',
format=format,
dataset=dataset,
**request.params))
handle_request(request, c, c.dataset)
return templating.render('entry/index.html')
def view(self, dataset, source, id, format='html'):
self._get_run(dataset, source, id)
system = c.run.records.filter_by(category=LogRecord.CATEGORY_SYSTEM)
c.num_system = system.count()
c.system_page = templating.Page(system.order_by(LogRecord.timestamp.asc()),
page=self._get_page('system_page'),
items_per_page=10)
data = c.run.records.filter_by(category=LogRecord.CATEGORY_DATA)
c.num_data = data.count()
c.data_page = templating.Page(data.order_by(LogRecord.timestamp.asc()),
page=self._get_page('data_page'),
items_per_page=20)
return templating.render('run/view.html')
def new(self, dataset, errors={}):
self._get_dataset(dataset)
self._disable_cache()
handle_request(request, c, c.dataset)
c.widgets = dict([(n, widgets.get_widget(n))
for n in widgets.list_widgets()])
if 'dev_widget' in request.params and \
request.params.get('dev_widget') not in widgets.list_widgets():
n = request.params.get('dev_widget')
c.widgets[n] = widgets.get_widget(n, force=True)
c.errors = errors
c.can_save = can.view.create(c.dataset)
return templating.render('view/new.html')
def trigger_reset(self):
"""
Allow user to trigger a reset of the password in case they forget it
"""
# Disable the cache
self._disable_cache()
# If it's a simple GET method we return the form
if request.method == 'GET':
return templating.render('account/trigger_reset.html')
# Get the email
email = request.params.get('email')
# Simple check to see if the email was provided. Flash error if not
if email is None or not len(email):
h.flash_error(_("Please enter an email address!"))
return templating.render('account/trigger_reset.html')
# Get the account for this email
account = Account.by_email(email)
# If no account is found we let the user know that it's not registered
if account is None:
h.flash_error(_("No user is registered under this address!"))
return templating.render('account/trigger_reset.html')
# Send the reset link to the email of this account
send_reset_link(account)
# Let the user know that email with link has been sent
h.flash_success(
_("You've received an email with a link to reset your " +
"password. Please check your inbox."))
# Redirect to the login page
redirect(h.url_for(controller='account', action='login'))
def view(self, dataset, source, id, format='html'):
self._get_run(dataset, source, id)
system = c.run.records.filter_by(category=LogRecord.CATEGORY_SYSTEM)
c.num_system = system.count()
c.system_page = templating.Page(
system.order_by(LogRecord.timestamp.asc()),
page=self._get_page('system_page'),
items_per_page=10)
data = c.run.records.filter_by(category=LogRecord.CATEGORY_DATA)
c.num_data = data.count()
c.data_page = templating.Page(data.order_by(LogRecord.timestamp.asc()),
page=self._get_page('data_page'),
items_per_page=20)
return templating.render('run/view.html')
def view(self, dataset, format='html'):
"""
Dataset viewer. Default format is html. This will return either
an entry index if there is no default view or the defaul view.
If a request parameter embed is given the default view is
returned as an embeddable page.
If json is provided as a format the json representation of the
dataset is returned.
"""
# Get the dataset (will be placed in c.dataset)
self._get_dataset(dataset)
# Generate the etag for the cache based on updated_at value
etag_cache_keygen(c.dataset.updated_at)
# Compute the number of entries in the dataset
c.num_entries = len(c.dataset)
# Handle the request for the dataset, this will return
# a default view in c.view if there is any
handle_request(request, c, c.dataset)
if format == 'json':
# If requested format is json we return the json representation
return to_jsonp(dataset_apply_links(c.dataset.as_dict()))
else:
(earliest_timestamp, latest_timestamp) = c.dataset.timerange()
if earliest_timestamp is not None:
c.timerange = {
'from': earliest_timestamp,
'to': latest_timestamp
}
if c.view is None:
# If handle request didn't return a view we return the
# entry index
return EntryController().index(dataset, format)
if 'embed' in request.params:
# If embed is requested using the url parameters we return
# a redirect to an embed page for the default view
return redirect(
h.url_for(controller='view',
action='embed',
dataset=c.dataset.name,
widget=c.view.vis_widget.get('name'),
state=json.dumps(c.view.vis_state)))
# Return the dataset view (for the default view)
return templating.render('dataset/view.html')
def trigger_reset(self):
"""
Allow user to trigger a reset of the password in case they forget it
"""
# Disable the cache
self._disable_cache()
# If it's a simple GET method we return the form
if request.method == 'GET':
return templating.render('account/trigger_reset.html')
# Get the email
email = request.params.get('email')
# Simple check to see if the email was provided. Flash error if not
if email is None or not len(email):
h.flash_error(_("Please enter an email address!"))
return templating.render('account/trigger_reset.html')
# Get the account for this email
account = Account.by_email(email)
# If no account is found we let the user know that it's not registered
if account is None:
h.flash_error(_("No user is registered under this address!"))
return templating.render('account/trigger_reset.html')
# Send the reset link to the email of this account
send_reset_link(account)
# Let the user know that email with link has been sent
h.flash_success(_("You've received an email with a link to reset your "
+ "password. Please check your inbox."))
# Redirect to the login page
redirect(h.url_for(controller='account', action='login'))
def index(self, format='html'):
"""
List all badges in the system. Default is to present the
user with an html site, but the user can request a json list
of badges.
"""
c.badges = Badge.all()
# If the requested format is json return a list of badges
if format == 'json':
return to_jsonp({"badges":badges_apply_links([b.as_dict()
for b in c.badges])})
# Return html representation
return templating.render('badge/index.html')
def entries(self, dataset, dimension, name, format='html'):
self._get_member(dataset, dimension, name)
if format in ['json', 'csv']:
return redirect(
url_for(controller='api/version2',
action='search',
format=format,
dataset=dataset,
filter='%s.name:%s' % (dimension, name),
**request.params))
handle_request(request, c, c.member, c.dimension.name)
entries = c.dataset.entries(
c.dimension.alias.c.name == c.member['name'])
entries = (entry_apply_links(dataset, e) for e in entries)
return templating.render('dimension/entries.html')
def information(self, id, format='html'):
"""
Show information about the badge. Default is to present the
user with the badge on an html site, but the user can request a
json representation of the badge
"""
# Get the badge
c.badge = Badge.by_id(id=id)
# Return a json representation if the format requested is 'json'
if format == 'json':
return to_jsonp({"badge": badge_apply_links(c.badge.as_dict())})
# Return html representation
return templating.render('badge/information.html')
