def search(self): c.q = request.params.get('q', None) if not c.q: return render('account/search.html') query = search.account_query(c.q) c.page = Page( collection=query, page=int(request.params.get('page', 1)), items_per_page=c.items_per_page, item_count=query.count(), q=c.q, # Preserve `q` when the user clicks 'next' or 'previous'. ) return render('account/results.html')
def index(self): # c.items_per_page = 100 page = int(request.params.get('page', 1)) c.name = u'programme_object_group_code' c.codes = self._db.coins.distinct(c.name) def code_count(code): return self._db.coins.find({c.name: code}, [c.name]).count() def get_desc(code): colname = c.name.replace('_code', '_description') out = self._db.coins.find_one({c.name: code}, [colname]) if colname in out: return out[colname] else: return None def get_link(code): link = url(controller='coins', action='index', q='%s:%s' % (c.name, code)) return link c.results = [[code, get_link(code), get_desc(code), code_count(code)] for code in c.codes] c.page = Page( collection=c.results, page=page, items_per_page=len(c.results), ) return render('pog/index.html')
def view(self, name_or_id=None): c.row = self.get_by_name_or_id(model.Slice, name_or_id) c.num_accounts = (model.Session.query( model.Account).filter_by(slice_=c.row)).count() c.num_transactions = (model.Session.query( model.Transaction).filter_by(slice_=c.row)).count() return render('slice/view.html')
def transactions(self, name_or_id=None): c.slice_ = self.get_by_name_or_id(model.Slice, name_or_id) query = model.Session.query( model.Transaction).filter_by(slice_=c.slice_) c.page = Page(collection=query, page=int(request.params.get('page', 1)), items_per_page=c.items_per_page, item_count=query.count()) return render('slice/transactions.html')
def index(self): query = model.Session.query(model.Transaction) c.page = Page( collection=query, page=int(request.params.get('page', 1)), items_per_page=c.items_per_page, item_count=query.count(), ) return render('transaction/index.html')
def index(self): c.rest_url = url(controller='rest', action='index') # Construct query strings by hand to keep the parameters in an instructive order. c.aggregate_url = url(controller='api', action='aggregate') + \ '?slice=%s' % c.default_slice + \ '&exclude-spender=yes&include-cofog1=07&breakdown-dept=yes&breakdown-region=yes&start_date=2004-05&end_date=2004-05' c.mytax_url = url(controller='api', action='mytax') + \ '?income=20000&spending=10000&smoker=yes&driver=yes' return render('home/api.html')
def view(self): # Read request parameters. slice_ = self.get_by_name_or_id(model.Slice, name_or_id=request.params.get('slice', c.default_slice)) c.filters = {} for param, value in request.params.items(): if param.startswith('include-'): key = self.get_by_name_or_id(model.Key, name_or_id=unicode(param[8:])) c.filters[key] = value c.axis = request.params.get('breakdown') if c.axis: c.axis = self.get_by_name_or_id(model.Key, name_or_id=c.axis) # TODO: Generalise this hard-wired data: key_spender = self.get_by_name_or_id(model.Key, name_or_id=u'spender') # Do the aggregation. c.results = aggregator.aggregate( slice_=slice_, exclude=[(key_spender, u'yes')], include=c.filters.items(), axes=[c.axis] if c.axis else [], ) # Function for making small changes to the URL. def make_url(add_filter_value=None, remove_filter_key=None): new_filters = dict(c.filters) new_axis = c.axis if add_filter_value: new_filters[c.axis] = add_filter_value new_axis = None # TODO: Make a better choice. if remove_filter_key: del new_filters[remove_filter_key] params = dict([('include-'+str(key.name), value) for key, value in new_filters.items()]) if new_axis: params['breakdown'] = new_axis.name return url(controller='aggregate', action='view', **params) # Generate info for filters. c.filter_labels = dict([(key.name, c.filters[key]) for key in c.filters]) c.filter_links = dict([(key.name, make_url(remove_filter_key=key)) for key in c.filters]) # Get all Keys for the breakdown drop-down menu. c.bd_keys = model.Session.query(model.Key).all() # Generate info for breakdown row headings. if c.axis: c.axis_labels = dict([(ev.code, u'%s: %s' % (ev.code, ev.name)) for ev in model.Session.query(model.EnumerationValue) .filter_by(key=c.axis).all()]) c.axis_links = dict([(coordinates[0], make_url(add_filter_value=coordinates[0])) for coordinates in c.results.matrix.keys()]) # Compute totals. c.totals = [0.0 for date in c.results.dates] for data in c.results.matrix.values(): for i, amount in enumerate(data): c.totals[i] += amount # TODO: Omit keys that are useless. How to define? return render('aggregate/view.html')
def accounts(self, name_or_id=None): c.items_per_page = int(request.params.get('items_per_page', 50)) c.slice_ = self.get_by_name_or_id(model.Slice, name_or_id) query = model.Session.query(model.Account).filter_by( slice_=c.slice_).order_by(model.Account.name) c.page = Page(collection=query, page=int(request.params.get('page', 1)), items_per_page=c.items_per_page, item_count=query.count()) return render('slice/accounts.html')
def accounts(self, name_or_id=None): c.row = self.get_by_name_or_id(model.Key, name_or_id) query = (model.Session.query(model.Account).join( (model.KeyValue, model.Account.id == model.KeyValue.object_id)).filter_by( key=c.row).order_by(model.Account.id)) c.page = Page(collection=query, page=int(request.params.get('page', 1)), items_per_page=c.items_per_page, item_count=query.count()) return render('key/accounts.html')
def view(self, name_or_id=None): c.row = self.get_by_name_or_id(model.Key, name_or_id) c.num_accounts = (model.Session.query(model.KeyValue).filter_by( key=c.row).filter_by(ns=u'account')).count() c.num_enumeration_values = (model.Session.query( model.KeyValue).filter_by(key=c.row).filter_by( ns=u'enumeration_value')).count() query = model.Session.query( model.EnumerationValue).filter_by(key_id=c.row.id) c.page = Page(collection=query, page=int(request.params.get('page', 1)), items_per_page=c.items_per_page, item_count=query.count()) return render('key/view.html')
def view(self, year, field): dataset = 'fact_table_extract_%s' % year c.field = field query = app_globals.solr.query('srcid:%s*' % dataset, facet='true', facet_field=field) c.facet_counts = query.facet_counts['facet_fields'][c.field] c.descriptions = {} if field.endswith('code'): for k in c.facet_counts: entry = model.get_one_entry(k, c.field) if entry: c.descriptions[k] = entry.get( c.field.replace('code', 'description'), '') return render('facet/view.html')
def postings(self, id_=None): c.row = self.get_by_id(model.Account, id_) query = (model.Session.query( model.Posting).filter_by(account=c.row).order_by('timestamp')) # TODO: as sql # import wdmmg.model.atp as atp # amountq = atp.table_posting.select().where( # atp.table_posting.c.account_id==c.row.id # ).group_by(atp.table_posting.c.timestamp) # c.amount = amountq.execute().fetchall() c.amounts = {} for posting in query: c.amounts[posting.timestamp] = c.amounts.get(posting.timestamp, 0) + posting.amount c.page = Page(collection=query, page=int(request.params.get('page', 1)), items_per_page=c.items_per_page, item_count=query.count()) return render('account/postings.html')
def view(self, name_or_id=None, code=None): ''' name_or_id - a `Key.name` or `Key.id`. code - an `EnumerationValue.code`. ''' c.key = self.get_by_name_or_id(model.Key, name_or_id) c.row = (model.Session.query(model.EnumerationValue).filter_by( key=c.key).filter_by(code=code)).first() q = model.Session.query(model.Account) q = q.join( (model.KeyValue, model.KeyValue.object_id == model.Account.id)) q = q.join(model.Key) q = q.join(model.EnumerationValue) print q.filter(model.Key.name == c.key.name) c.accounts = q.filter(model.EnumerationValue.id == c.row.id).filter( model.Key.name == c.key.name, ).distinct().all() if not c.row: abort(404, 'No record with code %r' % code) return render('enumeration_value/view.html')
def index(self): slice_ = model.Session.query(model.Slice).first() enumeration_value = model.Session.query(model.EnumerationValue).first() key = enumeration_value.key c.urls = [ url(controller='rest', action='slice', name_or_id=slice_.name), url(controller='rest', action='slice', name_or_id=slice_.id), url(controller='rest', action='account', id_=model.Session.query(model.Account).first().id), url(controller='rest', action='transaction', id_=model.Session.query(model.Transaction).first().id), url(controller='rest', action='key', name_or_id=key.name), url(controller='rest', action='key', name_or_id=key.id), url(controller='rest', action='enumeration_value', name_or_id=enumeration_value.key.name, code=enumeration_value.code), ] return render('home/rest.html')
def index_solr(self): c.items_per_page = 100 c.q = request.params.get('q', None) page = int(request.params.get('page', 1)) if c.q: query = app_globals.solr.query(c.q, rows=c.items_per_page, q_op='AND') else: query = app_globals.solr.query('*', sort='score desc, value desc', rows=c.items_per_page) c.results = query.results c.page = Page( collection=c.results, page=page, items_per_page=c.items_per_page, item_count=query.numFound, q=c.q, # Preserve `q` when the user clicks 'next' or 'previous'. ) return render('coins/index.html')
def index(self): all_keys = model.Session.query(model.Key).all() # Make ourselves an index of keys by name. c.by_name = {} # name -> Key for key in all_keys: c.by_name[key.name] = key parent_key = self.get_by_name_or_id(model.Key, name_or_id=u'parent') # Identify keys with/without parents. c.parents = {} # name -> name c.by_parent = {} # name -> list of names for key in all_keys: if parent_key in key.keyvalues: c.parents[key.name] = key.keyvalues[parent_key] else: c.by_parent[key.name] = [] # For each key that has a parent, attach it to its ultimate ancestor. for name in c.parents: parent = c.parents[name] while parent in c.parents: parent = c.parents[parent] c.by_parent[parent].append(name) return render('key/index.html')
def total(self): values = dict(request.params) c.values = values # if programme_object_code in request.params: # undo hack in link creation # po = request.params['po.replace('|', '/') # q += ' programme_object_code:"%s"' % po q = '' # id for use in e.g. disqus c.pageid = '' for k in sorted(values.keys()): v = values[k] q += '%s:"%s" ' % (k, v) c.pageid += '%s::%s::' % (k, v) # " are not allowed in the pageid c.pageid = c.pageid.replace('"', "'") c.pageid = c.pageid.replace('&', "amp;") c.pageid = c.pageid.replace('<', "lt;") query = app_globals.solr.query(q, rows=2000, q_op='AND') c.results = query.results c.count = query.numFound if c.count > 2000: return 'Too many entries (%s) to sum' % c.count else: # put into years # exclude net parliamentary funding npf_account_code = '31070000' c.total = {} c.npf = {} for hit in query: year = hit['dataset'].split('_')[3] if hit['account_code'] != npf_account_code: # convert to millions c.total[year] = c.total.get(year, 0) + hit['value'] / 1000.0 else: c.npf[year] = c.npf.get(year, 0) + hit['value'] / 1000.0 return render('facet/total.html')
def index_mongo(self): from pymongo import ASCENDING, DESCENDING c.items_per_page = 100 c.q = request.params.get('q', None) page = int(request.params.get('page', 1)) if c.q: # textq = '/.*%s.*/i' % c.q dbq = self._db.coins.find({'search_field': {'$all': c.q.split()}}) dbq.sort('value', DESCENDING) else: dbq = self._db.coins.find().sort('value', DESCENDING) c.results = [ x for x in dbq.limit(c.items_per_page).skip((page - 1) * c.items_per_page) ] c.page = Page( collection=c.results, page=page, items_per_page=c.items_per_page, item_count=dbq.count(), q=c.q, # Preserve `q` when the user clicks 'next' or 'previous'. ) return render('coins/index.html')
def index(self): c.limit = int(request.params.get('limit', '100')) # TODO: Nicer error message. c.results = model.Session.query(model.Slice)[:c.limit] return render('slice/index.html')
def view_id(self, id_=None): '''Deprecated.''' c.row = self.get_by_id(model.EnumerationValue, id_) c.key = c.row.key return render('enumeration_value/view.html')
def view(self, id_=None): c.row = self.get_by_id(model.Transaction, id_) return render('transaction/view.html')
def view(self, id): c.entry = model.get_one_entry(id) if not c.entry: abort(404) return render('coins/entry.html')
def index(self): return render('facet/index.html')
def index(self): c.slice_count = model.Session.query(model.Slice).count() c.account_count = model.Session.query(model.Account).count() c.transaction_count = model.Session.query(model.Transaction).count() c.key_count = model.Session.query(model.Key).count() return render('home/index.html')
def view(self, id_=None): c.row = self.get_by_id(model.Account, id_) c.num_postings = (model.Session.query( model.Posting).filter_by(account=c.row)).count() return render('account/view.html')
def view(self, id): c.entry = self._db.coins.find_one({'srcid': id}) if not c.entry: abort(404) return render('coins/entry.html')