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 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 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 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 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 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, 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 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, 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 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 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 render("entry/index.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 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')
def entries(self, dataset, dimension, name, format='html'):
self._get_member(dataset, dimension, name)
if format in ['json', 'csv']:
return redirect(url_for(controller='api2', 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 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 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, format='html'):
self._get_dataset(dataset)
c.num_entries = len(c.dataset)
handle_request(request, c, c.dataset)
if c.view is None and format == 'html':
return EntryController().index(dataset, format)
if format == 'json':
return to_jsonp(dataset_apply_links(c.dataset.as_dict()))
else:
return render('dataset/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)
# 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 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_html(self, classifier):
c.classifier = classifier
handle_request(request, c, c.classifier)
if c.view is None:
self._make_browser()
c.num_entries = self._entry_q(c.classifier).count()
c.template = 'classifier/view.html'
for item in self.extensions:
item.read(c, request, response, c.classifier)
return render(c.template)
def _view_html(self, dataset):
c.dataset = dataset
c.num_entries = model.entry.find({'dataset.name': dataset['name']}).count()
c.template = 'dataset/view.html'
handle_request(request, c, c.dataset)
if c.view is None:
self._make_browser()
for item in self.extensions:
item.read(c, request, response, c.dataset)
return render(c.template)
def index(self, dataset, format='html'):
self._get_dataset(dataset)
handle_request(request, c, c.dataset)
url = h.url_for(controller='entry', action='index',
dataset=c.dataset.name)
c.browser = Browser(c.dataset, request.params, url=url)
c.browser.facet_by_dimensions()
if format == 'json':
return c.browser.to_jsonp()
elif format == 'csv':
return c.browser.to_csv()
else:
return render('entry/index.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 _view_html(self, entity):
c.entity = entity
handle_request(request, c, c.entity)
if c.view is None:
self._make_browser()
c.num_entries = self._entry_q(c.entity).count()
c.template = "entity/view.html"
for item in self.extensions:
item.read(c, request, response, c.entity)
return render(c.template)
def entries(self, dataset, dimension, name, format="html"):
self._get_member(dataset, dimension, name)
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)
attachment_name = "__".join([dataset, dimension, name])
if format == "json":
return write_json(entries, response, filename=attachment_name + ".json")
elif format == "csv":
return write_csv(entries, response, filename=attachment_name + ".csv")
else:
return render("dimension/entries.html")
def entries(self, dataset, dimension, name, format='html'):
self._get_member(dataset, dimension, name)
handle_request(request, c, c.member, c.dimension)
attachment_name = '__'.join([dataset, dimension, name])
self._make_browser()
if format == 'json':
return c.browser.to_jsonp()
elif format == 'csv':
response.content_disposition = 'attachment; filename=%s.csv' % attachment_name
return c.browser.to_csv()
else:
return render('dimension/entries.html')
def entries(self, dataset, dimension, name, format='html'):
self._get_member(dataset, dimension, name)
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)
attachment_name = '__'.join([dataset, dimension, name])
if format == 'json':
return write_json(entries, response, filename=attachment_name + '.json')
elif format == 'csv':
return write_csv(entries, response, filename=attachment_name + '.csv')
else:
return render('dimension/entries.html')
def member(self, dataset, dimension, name, format="html"):
self._get_member(dataset, dimension, name)
handle_request(request, c, c.member, c.dimension)
if c.view is None:
self._make_browser()
for item in self.extensions:
item.read(c, request, response, c.member)
if format == 'json':
return to_jsonp(c.member)
elif format == 'csv':
return write_csv([c.member], response)
else:
return render('dimension/member.html')
def member(self, dataset, dimension, name, format="html"):
self._get_member(dataset, dimension, name)
handle_request(request, c, c.member, c.dimension)
if c.view is None:
self._make_browser()
for item in self.extensions:
item.read(c, request, response, c.member)
if format == 'json':
return to_jsonp(c.member)
elif format == 'csv':
return write_csv([c.member], response)
else:
return render('dimension/member.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 _view_html(self, dataset):
c.dataset = dataset
# TODO: make this a method
entry_query = self._entry_q(dataset)
c.num_entries = logic.entry.count(**entry_query)
c.template = 'dataset/view.html'
handle_request(request, c, c.dataset)
if c.view is None:
self._make_browser()
for item in self.extensions:
item.read(c, request, response, c.dataset)
return render(c.template)
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 member(self, dataset, dimension, name, format="html"):
self._get_member(dataset, dimension, name)
handle_request(request, c, c.member, c.dimension.name)
# If there are no views set up, then go direct to the entries search page
if c.view is None and format is "html":
return redirect(url_for(controller='dimension', action='entries',
dataset=c.dataset.name, dimension=dimension, name=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:
return render('dimension/member.html')
def view(self, dataset, format='html'):
self._get_dataset(dataset)
etag_cache_keygen(c.dataset.updated_at)
c.num_entries = len(c.dataset)
handle_request(request, c, c.dataset)
if format == 'json':
return to_jsonp(dataset_apply_links(c.dataset.as_dict()))
else:
if c.view is None:
return EntryController().index(dataset, format)
if 'embed' in request.params:
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 templating.render('dataset/view.html')
def view(self, dataset, format='html'):
self._get_dataset(dataset)
c.num_entries = len(c.dataset)
handle_request(request, c, c.dataset)
if c.view is None and format == 'html':
return EntryController().index(dataset, format)
for item in self.extensions:
item.read(c, request, response, c.dataset)
if format == 'json':
return to_jsonp(c.dataset.as_dict())
elif format == 'csv':
return write_csv([c.dataset.as_dict()], response)
else:
return render('dataset/view.html')
def view(self, dataset, format='html'):
self._get_dataset(dataset)
c.num_entries = len(c.dataset)
handle_request(request, c, c.dataset)
if c.view is None and format == 'html':
return EntryController().index(dataset, format)
for item in self.extensions:
item.read(c, request, response, c.dataset)
if format == 'json':
return to_jsonp(c.dataset.as_dict())
elif format == 'csv':
return write_csv([c.dataset.as_dict()], response)
else:
return render('dataset/view.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="api2",
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 view(self, dataset, format='html'):
self._get_dataset(dataset)
etag_cache_keygen(c.dataset.updated_at)
c.num_entries = len(c.dataset)
handle_request(request, c, c.dataset)
if format == 'json':
return to_jsonp(dataset_apply_links(c.dataset.as_dict()))
else:
if c.view is None:
return EntryController().index(dataset, format)
if 'embed' in request.params:
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 templating.render('dataset/view.html')
def entries(self, dataset, dimension, name, format='html'):
self._get_member(dataset, dimension, name)
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)
attachment_name = '__'.join([dataset, dimension, name])
if format == 'json':
return write_json(entries,
response,
filename=attachment_name + '.json')
elif format == 'csv':
return write_csv(entries,
response,
filename=attachment_name + '.csv')
else:
return render('dimension/entries.html')
def create(self, dataset):
self._get_dataset(dataset)
require.view.create(c.dataset)
handle_request(request, c, c.dataset)
try:
data = CreateView().deserialize(request.params)
view = View()
view.dataset = c.dataset
view.account = c.account
view.widget = data['widget']
view.state = data['state']
view.name = make_name(c.dataset, data['label'])
view.label = data['label']
view.description = data['description']
view.public = True
db.session.add(view)
db.session.commit()
redirect(h.url_for(controller='view', action='view',
dataset=c.dataset.name, name=view.name))
except colander.Invalid as inv:
return self.new(dataset, errors=inv.asdict())
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 (dataset, entry)
solr_entries = b.get_entries()
# We are only interested in the entry in the tuple since we know
# the dataset
entries = [entry[1] for 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 index(self, dataset, format='html'):
self._get_dataset(dataset)
handle_request(request, c, c.dataset)
return render('entry/index.html')
