def new(self, errors={}):
self._disable_cache()
if not has.dataset.create():
return 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 render(
"dataset/new.html", form_errors=dict(errors), form_fill=request.params if errors else {"currency": "USD"}
)
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): 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)
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 render('editor/core.html',
form_errors=dict(errors),
form_fill=fill)
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 render("entry/view.html")
def view(self, dataset, dimension, format='html'):
self._get_dataset(dataset)
try:
c.dimension = c.dataset[dimension]
except KeyError:
abort(404, _('This is not a dimension'))
if not isinstance(c.dimension, model.Dimension):
abort(404, _('This is not a dimension'))
page = self._get_page('page')
cache = AggregationCache(c.dataset)
result = cache.aggregate(drilldowns=[dimension], page=page,
pagesize=PAGE_SIZE)
items = result.get('drilldown', [])
c.values = [(d.get(dimension), d.get('amount')) for d in items]
if format == 'json':
return to_jsonp({
"values": c.values,
"meta": c.dimension.as_dict()})
c.page = Page(c.values, page=page,
item_count=result['summary']['num_drilldowns'],
items_per_page=PAGE_SIZE,
presliced_list=True)
return render('dimension/view.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 render('dimension/member.html')
def index(self):
# subdomain override:
if hasattr(c, "dataset") and c.dataset:
redirect(url(controller="dataset", action="view", id=c.dataset.name))
featured_dataset = config.get("openspending.default_dataset", "cra")
c.datasets = list(model.Dataset.find())
c.dataset = filter(lambda x: x.name == featured_dataset, c.datasets)
if c.dataset:
c.dataset = c.dataset[0]
elif c.datasets:
c.dataset = c.datasets[0]
else:
c.dataset = None
c.template = "home/index.html"
if c.dataset:
# TODO: make this a method
c.num_entries = model.Entry.find({"dataset.name": c.dataset.name}).count()
views.handle_request(request, c, c.dataset)
for item in self.extensions:
item.read(c, request, response, c.dataset)
return render(c.template)
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 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'
]:
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 render('../templates/%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 render('entry/view.html')
def bubbles(self, name, breakdown_field, drilldown_fields, format="html"):
c.drilldown_fields = json.dumps(drilldown_fields.split(','))
dataset = name
c.dataset = model.dataset.find_one_by('name', name)
c.dataset_name = name
# TODO: make this a method
c.template = 'dataset/view_bubbles.html'
curs = model.entry.find({'dataset.name':name})# , {breakdown_field: True})
breakdown_names = list(set([ i[breakdown_field]['name'] for i in curs ]))
count = len(breakdown_names)
styles = [ s for s in rgb_rainbow(count) ]
breakdown_styles = dict([ (breakdown_names[n], styles[n]) for n in range(0, count) ])
c.breakdown_styles = [ "'%s' : { color: '%s' }," % (k, v) for k, v in breakdown_styles.iteritems() ]
c.breakdown_field = breakdown_field
handle_request(request, c, c.dataset)
if c.view is None:
self._make_browser()
if hasattr(c, 'time'):
delattr(c, 'time') # disable treemap(!)
return render(c.template)
def view(self, dataset, dimension, format='html'):
self._get_dataset(dataset)
try:
c.dimension = c.dataset[dimension]
except KeyError:
abort(404, _('This is not a dimension'))
if not isinstance(c.dimension, model.Dimension):
abort(404, _('This is not a dimension'))
page = self._get_page('page')
cache = AggregationCache(c.dataset)
result = cache.aggregate(drilldowns=[dimension], page=page,
pagesize=PAGE_SIZE)
items = result.get('drilldown', [])
c.values = [(d.get(dimension), d.get('amount')) for d in items]
if format == 'json':
return to_jsonp({
"values": c.values,
"meta": c.dimension.as_dict()})
c.page = Page(c.values, page=page,
item_count=result['summary']['num_drilldowns'],
items_per_page=PAGE_SIZE,
presliced_list=True)
return render('dimension/view.html')
def index(self, format='html'):
for item in self.extensions:
item.index(c, request, response, c.results)
if format == 'json':
return to_jsonp(map(lambda d: d.as_dict(), c.datasets))
elif format == 'csv':
results = map(lambda d: d.as_dict(), c.datasets)
return write_csv(results, response)
else:
c.query = request.params.items()
c.add_filter = lambda f, v: '?' + urlencode(c.query + [(f, v)] if (
f, v) not in c.query else c.query)
c.del_filter = lambda f, v: '?' + urlencode([(k, x)
for k, x in c.query
if (k, x) != (f, v)])
c.results = c.datasets
for language in request.params.getall('languages'):
l = db.aliased(DatasetLanguage)
c.results = c.results.join(l, Dataset._languages)
c.results = c.results.filter(l.code == language)
for territory in request.params.getall('territories'):
t = db.aliased(DatasetTerritory)
c.results = c.results.join(t, Dataset._territories)
c.results = c.results.filter(t.code == territory)
c.results = list(c.results)
c.territory_options = DatasetTerritory.dataset_counts(c.results)
c.language_options = DatasetLanguage.dataset_counts(c.results)
return render('dataset/index.html')
def index(self, format='html'):
for item in self.extensions:
item.index(c, request, response, c.results)
if format == 'json':
return to_jsonp(map(lambda d: d.as_dict(),
c.datasets))
elif format == 'csv':
results = map(lambda d: d.as_dict(), c.datasets)
return write_csv(results, response)
else:
c.query = request.params.items()
c.add_filter = lambda f, v: '?' + urlencode(c.query +
[(f, v)] if (f, v) not in c.query else c.query)
c.del_filter = lambda f, v: '?' + urlencode([(k,x) for k, x in
c.query if (k,x) != (f,v)])
c.results = c.datasets
for language in request.params.getall('languages'):
l = db.aliased(DatasetLanguage)
c.results = c.results.join(l, Dataset._languages)
c.results = c.results.filter(l.code==language)
for territory in request.params.getall('territories'):
t = db.aliased(DatasetTerritory)
c.results = c.results.join(t, Dataset._territories)
c.results = c.results.filter(t.code==territory)
c.results = list(c.results)
c.territory_options = DatasetTerritory.dataset_counts(c.results)
c.language_options = DatasetLanguage.dataset_counts(c.results)
return render('dataset/index.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 render('entry/view.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 render("dataset/about.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 render('dataset/about.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 render('../templates/%s.html' % code)
else:
page = error_document_template % \
dict(prefix=request.environ.get('SCRIPT_NAME', ''),
code=code,
message=content)
return page
def index(self, dataset, format='html'):
self._get_dataset(dataset)
if format == 'json':
dimensions = [dimension_apply_links(dataset, d.as_dict()) \
for d in c.dataset.dimensions]
return to_jsonp(dimensions)
else:
return 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 render('content/view.html')
def new(self, errors={}):
c.currencies = sorted(CURRENCIES.items(), key=lambda (k,v): v)
require.account.create()
errors = [(k[len('dataset.'):], v) for k, v in errors.items()]
c.have_error = bool(errors)
c.dataset_info_style = '' if errors else 'display: none;'
return render('dataset/new.html', form_errors=dict(errors),
form_fill=request.params if errors else {'currency': 'USD'})
def trigger_reset(self):
self._disable_cache()
if request.method == 'GET':
return render('account/trigger_reset.html')
email = request.params.get('email')
if email is None or not len(email):
h.flash_error(_("Please enter an email address!"))
return render('account/trigger_reset.html')
account = Account.by_email(email)
if account is None:
h.flash_error(_("No user is registered under this address!"))
return render('account/trigger_reset.html')
send_reset_link(account)
h.flash_success(_("You've received an email with a link to reset your "
+ "password. Please check your inbox."))
redirect(h.url_for(controller='account', action='login'))
def index(self, dataset, code=None, format='html'):
self._get_dataset(dataset)
require.dataset.update(c.dataset)
handle_request(request, c, c.dataset)
if code is None:
code = CODE_SAMPLE
c.code = code
return render('mining/index.html')
def dropdb(self):
if config.get('openspending.sandbox_mode') != 'true':
abort(403, "Deleting the database is not permitted unless in sandbox mode")
return
from openspending.model import mongo
mongo.drop_collections()
return render('dataset/dropdb.html')
def views_edit(self, dataset, errors={}, views=None,
format='html'):
self._get_dataset(dataset)
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 render('editor/views.html', form_fill=c.fill)
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 render('view/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 render('editor/team.html')
def new(self, dataset, errors={}):
self._get_dataset(dataset)
handle_request(request, c, c.dataset)
c.widgets = dict([(n, widgets.get_widget(n)) \
for n in widgets.list_widgets()])
c.errors = errors
c.can_save = can.view.create(c.dataset)
return render('view/new.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 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 render('view/view.html')
def page(self, path):
suffix = 'help/%s' % path
for path in app_globals.genshi_loader.search_path:
filename = os.path.normpath(os.path.join(path, suffix))
if not (filename.startswith(path) and os.path.exists(filename)):
continue
return render(suffix)
abort(404, "Sorry, the selected help file could not be found")
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 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 render("dimension/index.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 render('view/index.html')
def views_edit(self, dataset, errors={}, views=None,
format='html'):
self._get_dataset(dataset)
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 render('editor/views.html', form_fill=c.fill)
def view(self, dataset, dimension, format='html'):
self._get_dimension(dataset, dimension)
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 render('dimension/view.html')
def page(self, path):
suffix = 'help/%s' % path
for path in app_globals.genshi_loader.search_path:
filename = os.path.normpath(os.path.join(path, suffix))
if not (filename.startswith(path)
and os.path.exists(filename)):
continue
return render(suffix)
abort(404, _("Sorry, the selected help file could not be found"))
def profile(self, name=None):
c.config = config
account = Account.by_name(name)
if account is None:
response.status = 404
return None
c.profile = account
c.is_admin = True if (c.account and c.account.admin is True) else False
return render('account/profile.html')
def trigger_reset(self):
self._disable_cache()
if request.method == 'GET':
return render('account/trigger_reset.html')
email = request.params.get('email')
if email is None or not len(email):
h.flash_error(_("Please enter an email address!"))
return render('account/trigger_reset.html')
account = Account.by_email(email)
if account is None:
h.flash_error(_("No user is registered under this address!"))
return render('account/trigger_reset.html')
send_reset_link(account)
h.flash_success(
_("You've received an email with a link to reset your " +
"password. Please check your inbox."))
redirect(h.url_for(controller='account', action='login'))
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 render("dimension/view.html")
def profile(self, name=None):
c.config = config
account = Account.by_name(name)
if account is None:
response.status = 404
return None
c.profile = account
c.is_admin = True if (c.account and c.account.admin is True) else False
return render('account/profile.html')
def dimensions_edit(self, dataset, errors={}, mapping=None,
format='html', saved=False):
self._get_dataset(dataset)
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 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 render('editor/dimensions_errors.html')
return render('editor/dimensions.html', form_fill=c.fill)
def index(self):
dataset_ = model.dataset.find_one()
c.urls = [
url(controller='dataset', action='view', name=dataset_['name'],
format='json'),
url(controller='entry', action='view',
id=model.entry.find_one()['_id'], format='json')]
return render('home/rest.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 render('editor/templates.html', form_fill=c.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 render('editor/team.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 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 render('dimension/view.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 render('editor/templates.html', form_fill=c.fill)
def index(self, dataset, format='html'):
self._get_dataset(dataset)
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 render('editor/index.html')
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 render('home/rest.html')
def new(self, errors={}):
c.currencies = sorted(CURRENCIES.items(), key=lambda (k, v): v)
require.account.create()
errors = [(k[len('dataset.'):], v) for k, v in errors.items()]
c.have_error = bool(errors)
c.dataset_info_style = '' if errors else 'display: none;'
return render(
'dataset/new.html',
form_errors=dict(errors),
form_fill=request.params if errors else {'currency': 'USD'})
def new(self, errors={}):
self._disable_cache()
if not has.dataset.create():
return 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 render(
'dataset/new.html',
form_errors=dict(errors),
form_fill=request.params if errors else {'currency': 'USD'})
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 render('view/embed.html')
def core_edit(self, dataset, errors={}, format='html'):
self._get_dataset(dataset)
require.dataset.update(c.dataset)
c.currencies = sorted(CURRENCIES.items(), 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)
errors = [(k[len('dataset.'):], v) for k, v in errors.items()]
fill = c.dataset.as_dict()
if errors:
fill.update(request.params)
return render('editor/core.html', form_errors=dict(errors),
form_fill=fill)
def entries(self, dataset, dimension, name, format='html'):
self._get_member(dataset, dimension, name)
handle_request(request, c, c.member, c.dimension)
self._make_browser()
if format == 'json':
return c.browser.to_jsonp()
elif format == 'csv':
return c.browser.to_csv()
else:
return render('dimension/entries.html')
class AccountController(BaseController):
def login(self):
self._disable_cache()
c.config = config
return render('account/login.html')
def register(self):
require.account.create()
c.config = config
self._disable_cache()
errors, values = {}, None
if request.method == 'POST':
try:
schema = AccountRegister()
values = request.params
data = schema.deserialize(values)
if Account.by_name(data['name']):
raise colander.Invalid(
AccountRegister.name,
_("Login name already exists, please choose a "
"different one"))
if not data['password1'] == data['password2']:
raise colander.Invalid(AccountRegister.password1,
_("Passwords don't match!"))
account = Account()
account.name = data['name']
account.fullname = data['fullname']
account.email = data['email']
account.password = generate_password_hash(data['password1'])
db.session.add(account)
db.session.commit()
who_api = get_api(request.environ)
authenticated, headers = who_api.login({
"login":
account.name,
"password":
data['password1']
})
errors = subscribe_lists(('community', 'developer'), data)
if errors:
h.flash_notice(
_("Subscription to the following mailing " +
"lists probably failed: %s.") % ', '.join(errors))
response.headers.extend(headers)
return redirect("/")
except colander.Invalid, i:
errors = i.asdict()
return render('account/login.html',
form_fill=values,
form_errors=errors)
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 render('view/new.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 = 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 = Page(data.order_by(LogRecord.timestamp.asc()),
page=self._get_page('data_page'),
items_per_page=20)
return render('run/view.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 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 render('editor/dimensions_errors.html')
return render('editor/dimensions.html', form_fill=c.fill)
