Пример #1
0
def bill_list(format, page=0, limit=50):
    bills = db.select('bill', limit=limit, offset=page*limit, order='session desc').list()
    out = apipublish.publish({
          'uri': apipublish.generic(lambda x: 'http://watchdog.net/b/' + x.id),
          'type': 'Bill',
          'title': apipublish.identity,
         }, bills, format)
    if out:
        return out
    return render.bill_list(bills, limit)
Пример #2
0
    def GET(self, format=None):
        i = web.input(address=None)
        join = ['district' + ' LEFT OUTER JOIN politician '
                             'ON (politician.district = district.name)']
        pzip5 = re.compile(r'\d{5}')
        pzip4 = re.compile(r'\d{5}-\d{4}')
        pname = re.compile(r'[a-zA-Z\.]+')
        pdist = re.compile(r'[a-zA-Z]{2}\-\d{2}')
        
        dist_struct = {
          'uri': apipublish.generic(lambda x: 'http://watchdog.net/us/' +
                                    x.name.lower()),
          'type': 'District',
          'name state district voting': apipublish.identity,
          'wikipedia': apipublish.URI,
        }

        if i.get('zip'):
            if pzip4.match(i.zip):
                zip, plus4 = i.zip.split('-')
                dists = [x.district for x in 
                  db.select('zip4', where='zip=$zip and plus4=$plus4', vars=locals())]
                d_dists = db.select('district', where=web.sqlors('name=', dists))
                
                out = apipublish.publish(dist_struct, d_dists, format)
                if out is not False:
                    return out
                
                if len(dists) == 0:
                    return render.find_none(i.zip)
                else: #@@ verify there aren't dupe districts
                    raise web.seeother('/us/%s' % dists[0].lower())
            
            if pzip5.match(i.zip):
                try:
                    dists = zip2rep.zip2dist(i.zip, i.address)
                except zip2rep.BadAddress:
                    return render.find_badaddr(i.zip, i.address)
                
                d_dists = db.select('district', where=web.sqlors('name=', dists))
                out = apipublish.publish(dist_struct, d_dists, format)
                if out is not False:
                    return out
            
                if len(dists) == 1:
                    raise web.seeother('/us/%s' % dists[0].lower())
                elif len(dists) == 0:
                    return render.find_none(i.zip)
                else:
                    dists = db.select(join, where=web.sqlors('name=', dists))
                    return render.find_multi(i.zip, dists)

            if pdist.match(i.zip):
                raise web.seeother('/us/%s' % i.zip)

            if pname.match(i.zip):
                in_name = i.zip.lower()
                name = in_name.replace(' ', '_')
                vars = {'name':'%%%s%%' % name}
                reps = db.select('politician', where="id like $name", vars=vars)
                if len(reps) == 0:
                    vars = {'name':'%%%s%%' % in_name}
                    reps = db.select('v_politician_name', where="name ilike $name", vars=vars)
                if len(reps) > 1:
                    return render.find_multi_reps(reps)
                else:
                    try:
                        rep = reps[0]
                        web.seeother('/p/%s' % rep.id)
                    except IndexError:
                        raise web.notfound

        else:
            out = apipublish.publish(dist_struct, db.select('district'), format)
            if out is not False:
                return out
            
            dists = db.select(join, order='name asc')
            return render.districtlist(dists)
Пример #3
0
 def GET(self, polid, format=None):
     if polid != polid.lower():
         raise web.seeother('/p/' + polid.lower())
     
     if polid == "" or polid == "index":
         p = db.select(['politician'], order='district asc').list()
         
         out = apipublish.publish({
           'uri': apipublish.generic(lambda x: 'http://watchdog.net/p/' +
                                     x.id),
           'type': 'Politician',
           'district': lambda x: apipublish.URI('http://watchdog.net/us/' +
                                                x.lower()),
           'wikipedia': apipublish.URI,
          }, p, format)
         if out is not False:
             return out
         
         return render.pollist(p)
     
     try:
         p = db.select(['politician', 'district'],
                       what=("politician.*, "
                             "district.center_lat as d0, "
                             "district.center_lng as d1, "
                             "district.zoom_level as d2"),
                       where=('id=$polid AND '
                              'district.name = politician.district'),
                       vars=locals())[0]
     except IndexError:
         raise web.notfound
     
     p.fec_ids = [x.fec_id for x in db.select('politician_fec_ids', what='fec_id', 
       where='politician_id=$polid', vars=locals())]
     
     p.interest_group_rating = interest_group_ratings(polid)
     p.interest_group_table = interest_group_table(p.interest_group_rating)
     p.related_groups = group_politician_similarity(polid)
     p.sponsored_bills = bills_sponsored(polid)                           
         
     out = apipublish.publish({
       'uri': 'http://watchdog.net/p/' + polid,
       'type': 'Politician',
       'district': apipublish.URI('http://watchdog.net/us/' + p.district.lower()),
       'wikipedia photo_credit_url officeurl': apipublish.URI,
       'interest_group_rating': apipublish.table({
             'year groupname longname rating': apipublish.identity}),
       'related_groups' : apipublish.table({
             'longname': apipublish.identity,
             'num_bills_agreed': apipublish.generic(lambda g: g.agreed),
             'num_bills_voted': apipublish.generic(lambda g: g.total),
             'agreement_percent': apipublish.generic(lambda g: int(g.agreement * 100)),
             'group_politician_url': apipublish.generic(lambda g: 
                                     'http://watchdog.net/p/%s/%s' % (polid, g.id))
         }), 
         'sponsored_bills': apipublish.table({
             'id': apipublish.generic(lambda b: '%s. %s' % (b.type.upper(), b.number)),
             'session title introduced': apipublish.identity,
             'url': apipublish.generic(lambda b: 'http://watchdog.net/b/%s' % (b.id))
         }),
       'bioguideid opensecretsid govtrackid gender birthday firstname '
       'middlename lastname party religion photo_path '
       'photo_credit_text '
       'amt_earmark_requested n_earmark_requested n_earmark_received '
       'amt_earmark_received '
       'n_bills_introduced n_bills_enacted n_bills_debated '
       'n_bills_cosponsored '
       'icpsrid nominate predictability '
       'n_speeches words_per_speech '
       'fec_ids money_raised pct_spent pct_self '
       'pct_indiv pct_pac': apipublish.identity,
      }, [p], format)
     if out:
         return out
     
     return render.politician(p)