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 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 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 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 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 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 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 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 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')