6 |
7 | Non-Python Requirements
8 | -----------------------
9 | You will need all of the libraries to run [GeoDjango](https://docs.djangoproject.com/en/dev/ref/contrib/gis/install/). If you are so inclined, you can install most of these with [homebrew](https://github.com/mxcl/homebrew).
10 | [KyngChaos](http://www.kyngchaos.com/software:frameworks) may also be a useful resource for MacOS X users.
11 |
12 | * [GEOS](http://trac.osgeo.org/geos/)
13 | * [GDAL](http://www.gdal.org/)
14 | * [PROJ.4](http://trac.osgeo.org/proj/)
15 | * [PostGIS](http://postgis.refractions.net/)
16 | * [Mapnik2](http://trac.mapnik.org/wiki/Mapnik2) (not explicitly required but this generates map tiles, see below.)
17 |
18 | Getting Started
19 | ---------------
20 | 1. Set up a database using the [PostGIS spatial database template](https://docs.djangoproject.com/en/dev/ref/contrib/gis/install/#spatialdb-template).
21 | 2. Rename settings_local.example.py to settings_local.py and set your db/secretkey variables.
22 | 3. `pip install -r requirements.txt`
23 | 4. `python manage.py syncdb` creates the database schema.
24 | 5. `python manage.py update_db` imports initial data.
25 | 6. Generate GeoJSON files with `python manage.py geojson`
26 | 7. `git submodule update --init` adds bootstrap submodule
27 | 8. `python manage.py runserver`
28 |
29 | A Word on Mapnik
30 | ----------------
31 | [Mapnik2's Wiki](https://github.com/mapnik/mapnik/wiki/Mapnik2) has instructions for installing Mapnik2 on Mac OSX and Linux.
32 | Dane Springmeyer recently released [Mapnik2 binaries for Mac OSX](https://github.com/mapnik/mapnik/downloads).
33 |
34 | Database Update Script
35 | ----------------------
36 | To update data from the Open311 API, run `python manage.py update_db`.
37 | This command has a few options that may be useful. The first argument is
38 | the end date, defaults to yesterday. The second argument is the number
39 | of days to download previous to that date.
40 |
41 | * Ex: `python manage.py updatedb 2011-07-01 30` will download the entire
42 | month of June.
43 |
44 | To set up automatic updates (midnight every night):
45 |
46 | 1. `crontab -e`
47 | 2. Insert `0 0 * * * /path/to/dir/manage.py update_db`
48 |
49 | API Access
50 | ----------
51 | There are a number API calls to return JSON in various forms.
52 |
53 | * `/api`
54 | * `/tickets/(open|closed|both)`
55 | * `/[0-9]+` (n days previous to today)
56 | * `/YYYY-MM-DD(/[0-9]+)` (n days previous to the date)
57 | * `/YYYY-MM-DD/YYYY-MM-DD` (simple date range)
58 | * `/more_info/YYYY-MM-DD` (single day)
59 | * `/YYYY-MM-DD` (range)
60 | * `/list/YYYY-MM-DD` (singe day)
61 | * `/YYYY-MM-DD` (range)
62 |
63 | More Information
64 | ----------------
65 | Visit our [project page](http://codeforamerica.org/?cfa_project=open311-dashboard).
66 |
67 | Join the [official Open311 Dashboard mailing list](http://groups.google.com/group/open311-dashboard).
68 |
69 | [](http://stats.codeforamerica.org/projects/open311dashboard)
70 |
--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeforamerica/open311dashboard/891229ac922f8032d90658e0eef10562e79df622/__init__.py
--------------------------------------------------------------------------------
/dashboard/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeforamerica/open311dashboard/891229ac922f8032d90658e0eef10562e79df622/dashboard/__init__.py
--------------------------------------------------------------------------------
/dashboard/decorators.py:
--------------------------------------------------------------------------------
1 | from django.http import HttpResponse
2 |
3 | import json
4 |
5 | class ApiHandler(object):
6 | """When passed lists or dicts, it will return them in various serialized
7 | forms. Defaults to JSON, can also do JSONP."""
8 |
9 | def __init__(self, func):
10 | self.func = func
11 |
12 | def __call__(self, *args, **kwargs):
13 | request = args[0]
14 | format = request.GET.get('format')
15 |
16 | response = self.func(*args, **kwargs)
17 | if format == 'jsonp':
18 | data = json.dumps(response)
19 | callback = request.GET.get('callback')
20 |
21 | if callback:
22 | data = "%s(%s)" % (callback, data)
23 | mime_type = 'application/javascript'
24 | else:
25 | mime_type = 'application/json'
26 | data = json.dumps(response)
27 |
28 | return HttpResponse(data, content_type=mime_type)
29 |
--------------------------------------------------------------------------------
/dashboard/fixtures/initial_data.json:
--------------------------------------------------------------------------------
1 | [{"pk": 1, "model": "dashboard.city", "fields": {"paginated": false, "name": "San Francisco", "short_name": "", "url": "https://open311.sfgov.org/dev/Open311/v2/requests.xml", "jurisdiction_id": "sfgov.org", "api_key": ""}}]
--------------------------------------------------------------------------------
/dashboard/management/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeforamerica/open311dashboard/891229ac922f8032d90658e0eef10562e79df622/dashboard/management/__init__.py
--------------------------------------------------------------------------------
/dashboard/management/commands/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeforamerica/open311dashboard/891229ac922f8032d90658e0eef10562e79df622/dashboard/management/commands/__init__.py
--------------------------------------------------------------------------------
/dashboard/management/commands/geojson.py:
--------------------------------------------------------------------------------
1 | from django.core.management.base import BaseCommand
2 | from open311dashboard.dashboard.models import Geography, Request, Street
3 |
4 | from django.db import connection
5 | import json
6 |
7 | # TODO: ABSTRACT THIS!
8 | class Command(BaseCommand):
9 | help = """
10 |
11 | Grab relevant GeoJSON files to store and interact with the maps layer. We
12 | do not do this dynamically because the map layers are generated once a week
13 | and the JSON overlay should not interfere
14 |
15 | """
16 |
17 | def handle(self, *args, **options):
18 | geojson = {"type": "FeatureCollection",
19 | "features":[]
20 | }
21 | # Select JSON
22 |
23 | cursor = connection.cursor()
24 | cursor.execute("""
25 | SELECT a.* FROM(
26 | SELECT
27 | ST_AsGeoJSON(ST_Transform(ST_SetSRID(dashboard_street.line,900913),4326)),
28 | extract(epoch from avg(dashboard_request.updated_datetime - dashboard_request.requested_datetime)) as average,
29 | percent_rank() OVER (order by extract(epoch from avg(dashboard_request.updated_datetime - dashboard_request.requested_datetime))) as rank
30 | FROM dashboard_street
31 | LEFT OUTER JOIN
32 | dashboard_request ON (dashboard_street.id = dashboard_request.street_id)
33 | WHERE
34 | dashboard_request.status='Closed' AND
35 | dashboard_request.updated_datetime > dashboard_request.requested_datetime AND
36 | requested_datetime > '2010-12-31' AND
37 | dashboard_request.service_code = '024'
38 | GROUP BY dashboard_street.line
39 | ) AS a WHERE a.rank > .8
40 | """)
41 | rows = cursor.fetchall()
42 |
43 | for row in rows:
44 | geojson['features'].append({"type": "Feature",
45 | "geometry": json.loads(row[0]),
46 | "properties": {
47 | "percentile": "%s" % row[2]
48 | }})
49 | f = open('dashboard/static/sidewalk_cleaning.json', 'w')
50 | f.write(json.dumps(geojson))
51 | f.close()
52 |
53 | geojson['features'] = []
54 |
55 | cursor.execute("""
56 | SELECT a.* FROM(
57 | SELECT
58 | ST_AsGeoJSON(ST_Transform(ST_SetSRID(dashboard_street.line,900913),4326)),
59 | extract(epoch from avg(dashboard_request.updated_datetime - dashboard_request.requested_datetime)) as average,
60 | percent_rank() OVER (order by extract(epoch from avg(dashboard_request.updated_datetime - dashboard_request.requested_datetime))) as rank,
61 | dashboard_street.id
62 | FROM dashboard_street
63 | LEFT OUTER JOIN
64 | dashboard_request ON (dashboard_street.id = dashboard_request.street_id)
65 | WHERE
66 | dashboard_request.status='Closed' AND
67 | dashboard_request.updated_datetime > dashboard_request.requested_datetime AND
68 | requested_datetime > '2010-12-31' AND
69 | dashboard_request.service_code = '049'
70 | GROUP BY dashboard_street.line, dashboard_street.id
71 | ) AS a WHERE a.rank > .8
72 | """)
73 | rows = cursor.fetchall()
74 | for row in rows:
75 | geojson['features'].append({"type": "Feature",
76 | "geometry": json.loads(row[0]),
77 | "properties": {
78 | "percentile": "%s" % row[2],
79 | "id": "%s" % row[3]
80 | }})
81 | f = open('dashboard/static/graffiti.json', 'w')
82 | f.write(json.dumps(geojson))
83 | f.close()
84 |
85 |
86 | g = Geography.objects.all().transform()
87 | geojson['features'] = []
88 |
89 | for shape in g:
90 | geojson['features'].append({"type": "Feature",
91 | "geometry": json.loads(shape.geo.simplify(.0003,
92 | preserve_topology=True).json),
93 | "properties": {
94 | "neighborhood": shape.name,
95 | "id": shape.id
96 | }})
97 |
98 | h = open('dashboard/static/neighborhoods.json', 'w')
99 | h.write(json.dumps(geojson))
100 | h.close()
101 |
--------------------------------------------------------------------------------
/dashboard/management/commands/import.py:
--------------------------------------------------------------------------------
1 | from osgeo import ogr
2 | from django.contrib.gis.utils import LayerMapping
3 |
4 | from dashboard.models import Street
5 |
6 | ogr.UseExceptions()
7 | shapefile = ''
8 |
9 | source = ogr.Open(shapefile, 1)
10 |
11 | city_id_def = ogr.FieldDefn('CITY_ID', ogr.OFTInteger)
12 | layer = source.GetLayer()
13 | layer.CreateField(city_id_def)
14 |
15 | for feature in layer:
16 | feature.SetField('CITY_ID', 1)
17 | layer.SetFeature(feature)
18 | print "%s : %s" % (feature.GetField('STREETN_GC'), feature.GetField('CITY_ID'))
19 |
20 |
21 | mapping = {'line': 'LINESTRING',
22 | 'street_name': 'STREETN_GC',
23 | 'left_low_address': 'LF_FADD',
24 | 'left_high_address': 'LF_TOADD',
25 | 'right_low_address': 'RT_FADD',
26 | 'right_high_address': 'RT_TOADD',
27 | 'city': {'id': 'CITY_ID'}}
28 |
29 | lm = LayerMapping(Street, shapefile, mapping)
30 | lm.save(verbose=True)
31 |
--------------------------------------------------------------------------------
/dashboard/management/commands/update_db.py:
--------------------------------------------------------------------------------
1 | from django.core.management.base import BaseCommand, CommandError
2 | from django.core.exceptions import ValidationError
3 | from open311dashboard.dashboard.models import City, Request
4 | from dateutil import parser
5 |
6 | from optparse import make_option
7 | import urllib2
8 | import urllib
9 | import datetime as dt
10 | import xml.dom.minidom as dom
11 |
12 | ONE_DAY = dt.timedelta(days=1)
13 |
14 | def get_time_range(on_day=None):
15 | if on_day is None:
16 | on_day = dt.datetime.utcnow() - ONE_DAY
17 |
18 | # End at the begining of on_day; start at the beginning of the previous
19 | # day.
20 | end = on_day.replace(hour=0, minute=0, second=0, microsecond=0)
21 | start = end - ONE_DAY
22 |
23 | return (start, end)
24 |
25 | def parse_date(date_string):
26 | new_date = parser.parse(date_string)
27 | return new_date.strftime("%Y-%m-%d %I:%M")
28 |
29 | def validate_dt_value(datetime):
30 | """
31 | Verify that the given datetime will not cause problems for the Open311 API.
32 | For the San Francisco Open311 API, start and end dates are ISO8601 strings,
33 | but they are expected to be a specific subset.
34 | """
35 | if datetime.microsecond != 0:
36 | raise ValueError('Microseconds on datetime must be 0: %s' % datetime)
37 |
38 | if datetime.tzinfo is not None:
39 | raise ValueError('Tzinfo on datetime must be None: %s' % datetime)
40 |
41 | def get_requests_from_SF(start,end,page,city):
42 | """
43 | Retrieve the requests from the San Francisco 311 API within the time range
44 | specified by the dates start and end.
45 |
46 | Returns a stream containing the content from the API call.
47 | """
48 |
49 | validate_dt_value(start)
50 | validate_dt_value(end)
51 |
52 | #url = r'https://open311.sfgov.org/dev/Open311/v2/requests.xml' #dev
53 | url = city.url
54 | query_data = {
55 | 'start_date' : start.isoformat() + 'Z',
56 | 'end_date' : end.isoformat() + 'Z',
57 | 'jurisdiction_id' : city.jurisdiction_id,
58 | }
59 |
60 | if page > 0:
61 | query_data['page'] = page
62 |
63 | query_str = urllib.urlencode(query_data)
64 | print url + '?' + query_str
65 |
66 | requests_stream = urllib2.urlopen(url + '?' + query_str)
67 | return requests_stream
68 |
69 | def parse_requests_doc(stream):
70 | """
71 | Converts the given file-like object, which presumably contains a service
72 | requests document, into a list of request dictionaries.
73 | """
74 |
75 | import xml.dom
76 |
77 | xml_string = stream.read()
78 |
79 | columns = [] #holding columns for a day's worth of incident data
80 | values = [] #holding values for a day's worth of incident data
81 |
82 | try:
83 | requests_root = dom.parseString(xml_string).documentElement
84 | except ExpatError:
85 | print(xml_string)
86 | raise
87 |
88 | if len(requests_root.childNodes) < 1:
89 | return False
90 |
91 | for request_node in requests_root.childNodes:
92 | indiv_columns_list = []
93 | indiv_values_list = []
94 |
95 | if request_node.nodeType != xml.dom.Node.ELEMENT_NODE:
96 | continue
97 |
98 | if request_node.tagName != 'request':
99 | raise Exception('Unexpected node: %s' % requests_root.toprettyxml())
100 |
101 | for request_attr in request_node.childNodes:
102 | if request_attr.childNodes:
103 | if request_attr.tagName.find('datetime') > -1:
104 | request_attr.childNodes[0].data = parse_date(request_attr.childNodes[0].data)
105 |
106 | if request_attr.tagName in Request._meta.get_all_field_names():
107 | indiv_columns_list.append(request_attr.tagName)
108 | indiv_values_list.append(request_attr.childNodes[0].data)
109 |
110 | columns.append(indiv_columns_list)
111 | values.append(indiv_values_list)
112 | return (columns,values)
113 |
114 | def insert_data(requests, city):
115 | '''
116 | Takes the requests tuple, turns it into a dictionary, and saves it to the
117 | Requests model in django.
118 | '''
119 |
120 | columns,values = requests
121 |
122 | for i in range(len(values)):
123 |
124 | # Put the key-value pairs into a dictionary and then an arguments list.
125 | request_dict = dict(zip(columns[i], values[i]))
126 |
127 | # Check if the record already exists.
128 | try:
129 | exists = Request.objects.get(service_request_id = request_dict['service_request_id'],
130 | service_code = request_dict['service_code'])
131 | request_dict['id'] = exists.id
132 | except:
133 | pass
134 |
135 | r = Request(**request_dict)
136 |
137 | # Hardcoded for now.
138 | r.city_id = city.id
139 |
140 | try:
141 | r.save()
142 | print "Successfully saved %s" % r.service_request_id
143 | except ValidationError, e:
144 | raise CommandError('Request "%s" does not validate correctly\n %s' %
145 | (r.service_request_id, e))
146 |
147 | def process_requests(start, end, page, city):
148 | requests_stream = get_requests_from_SF(start, end, page, city)
149 | requests = parse_requests_doc(requests_stream)
150 |
151 | if requests != False:
152 | insert_data(requests, city)
153 |
154 | if page != 0:
155 | page = page+1
156 | process_requests(start, end, page, city)
157 | return requests
158 |
159 | def handle_open_requests(city):
160 | url = city.url
161 | open_requests = Request.objects.all().filter(status__iexact="open")
162 | length = len(open_requests)
163 | print "Checking %d tickets for changed status" % length
164 |
165 | for index in xrange(0, length, 10):
166 | data = []
167 | for i in xrange(0, 10):
168 | data.append(open_requests[index + i].service_request_id)
169 |
170 | query_data = {
171 | 'jurisdiction_id': city.jurisdiction_id,
172 | 'service_request_id': ','.join(data)
173 | }
174 |
175 | query_str = urllib.urlencode(query_data)
176 | print url + '?' + query_str
177 |
178 | requests_stream = urllib2.urlopen(url + '?' + query_str)
179 | try:
180 | print "Parsing open docs"
181 | requests = parse_requests_doc(requests_stream)
182 | print "Saving..."
183 | insert_data(requests)
184 | except:
185 | print "Could not process updates."
186 |
187 | # At runtime...
188 | class Command(BaseCommand):
189 | option_list = BaseCommand.option_list + (
190 | make_option('--checkopen', dest='open',
191 | default=False, help="Boolean to check open tickets"),
192 | make_option('--default', dest='default',
193 | default=True, help="Boolean to execute default functionality"),
194 | )
195 |
196 | help = """Update and seed the database from data retrieved from the API.
197 | Makes calls one day at a time"""
198 |
199 | def handle(self, *args, **options):
200 | cities = City.objects.all()
201 |
202 | for city in cities:
203 | if options['default'] is True:
204 | if len(args) >= 1:
205 | start, end = get_time_range(dt.datetime.strptime(args[0], '%Y-%m-%d'))
206 | else:
207 | start, end = get_time_range()
208 |
209 | if len(args) >= 2:
210 | num_days = int(args[1])
211 | print(args[1])
212 | else:
213 | num_days = 1
214 |
215 | if city.paginated:
216 | page = 1
217 | else:
218 | page = False
219 |
220 | for _ in xrange(num_days):
221 | requests = process_requests(start, end, page, city)
222 |
223 | start -= ONE_DAY
224 | end -= ONE_DAY
225 |
226 | print start
227 |
228 | if options['open'] is True:
229 | handle_open_requests()
230 |
231 |
232 |
--------------------------------------------------------------------------------
/dashboard/management/commands/utilities.py:
--------------------------------------------------------------------------------
1 | import datetime as dt
2 | from dateutil import parser
3 |
4 | ONE_DAY = dt.timedelta(days=1)
5 |
6 | def get_time_range(on_day=None):
7 | """
8 | Calculate a return a tuple of datetimes that are exactly 24
9 | hours apart, from midnight on the day passed in to the
10 | midnight prior. If the passed in value is None, then use
11 | datetime.utcnow() by default.
12 | """
13 |
14 | # ensure that on_day is defaulted to the previous day
15 | if on_day is None:
16 | on_day = dt.datetime.utcnow() - ONE_DAY
17 |
18 | # End at the begining of on_day; start at the beginning of the previous
19 | # day relative to on_day.
20 | end = on_day.replace(hour=0, minute=0, second=0, microsecond=0)
21 | start = end - ONE_DAY
22 |
23 | # return tuple of start and end
24 | return (start, end)
25 |
26 | def transform_date(date_string):
27 | """
28 | All Open311 date/time fields must be formatted in a common
29 | subset of ISO 8601 as per the w3 note. Timezone information
30 | (either Z meaning UTC, or an HH:MM offset from UTC) must be included.
31 | This method parses the Open311 date and transforms it into a simpler
32 | format and returns a string formatted as YYYY-MM-DD HH:MM.
33 | """
34 |
35 | new_date = parser.parse(date_string)
36 | return new_date.strftime("%Y-%m-%d %I:%M")
37 |
38 |
39 | # TODO:
40 | # Why is this test done every time? Why can't it be a unit test?
41 | # If microsends are non-zero and tzinfo is not None the first time
42 | # then why would it ever change?
43 | # The comments indicate that this is for the SF Open 311 API, is this
44 | # really SF specific or should it be done for every endpoint
45 | def validate_dt_value(datetime):
46 | """
47 | Verify that the given datetime will not cause problems for the Open311 API.
48 | For the San Francisco Open311 API, start and end dates are ISO8601 strings,
49 | but they are expected to be a specific subset.
50 | """
51 |
52 | if datetime.microsecond != 0:
53 | raise ValueError('Microseconds on datetime must be 0: %s' % datetime)
54 |
55 | if datetime.tzinfo is not None:
56 | raise ValueError('Tzinfo on datetime must be None: %s' % datetime)
57 |
58 |
59 |
--------------------------------------------------------------------------------
/dashboard/models.py:
--------------------------------------------------------------------------------
1 | from django.contrib.gis.db import models
2 | from django.contrib.gis.geos import Point
3 | from django.contrib.gis.measure import Distance as D
4 | from open311dashboard.settings import ENABLE_GEO
5 |
6 | class Request(models.Model):
7 | """
8 |
9 | The actual meat-n-potatoes of the 311 dashboard, all the data.
10 | Implementations are different so most of these fields are optional.
11 |
12 | Optional: PostGIS component set in settings.py
13 |
14 | """
15 | service_request_id = models.CharField(max_length=200)
16 | status = models.CharField(max_length=10)
17 | status_notes = models.TextField(blank=True, null=True)
18 | service_name = models.CharField(max_length=100)
19 | service_code = models.CharField(max_length=100, blank=True, null=True)
20 | description = models.TextField(blank=True, null=True)
21 | agency_responsible = models.CharField(max_length=255, blank=True, null=True)
22 | service_notice = models.CharField(max_length=255, blank=True, null=True)
23 | requested_datetime = models.DateTimeField()
24 | updated_datetime = models.DateTimeField(null=True, blank=True)
25 | expected_datetime = models.DateTimeField(null=True, blank=True)
26 | address = models.CharField(max_length=255)
27 | address_id = models.IntegerField(blank=True, null=True)
28 | zipcode = models.IntegerField(blank=True, null=True)
29 | lat = models.FloatField()
30 | long = models.FloatField()
31 | media_url = models.URLField(blank=True, null=True)
32 |
33 | city = models.ForeignKey('City')
34 |
35 | def get_service_name(self):
36 | return self.service_name.replace('_', ' ')
37 |
38 |
39 | # Super top secret geographic data.
40 | if ENABLE_GEO is True:
41 | geo_point = models.PointField(srid=900913, null=True)
42 | street = models.ForeignKey('Street', null=True)
43 | objects = models.GeoManager()
44 |
45 | def save(self):
46 | if (float(self.long) != 0.0 and float(self.lat) != 0.0):
47 | # Save the geo_point.
48 | point = Point(float(self.long), float(self.lat), srid=4326)
49 | point.transform(900913)
50 |
51 | self.geo_point = point
52 |
53 | # Lookup the nearest street
54 | street = Street.objects.filter(line__dwithin=(point, D(m=100))) \
55 | .distance(point).order_by('distance')[:1]
56 |
57 | if len(street) > 0:
58 | self.street = street[0]
59 |
60 | super(Request, self).save()
61 |
62 | # class Service(models.Model):
63 | """
64 |
65 | In a perfect world, this would be related to each Request but separate
66 | implementations are, again, different.
67 |
68 | """
69 | # service_code = models.CharField(max_length=100)
70 | # metadata = models.CharField(max_length=100)
71 | # type = models.CharField(max_length=50)
72 | # keywords = models.TextField(blank=True, null=True)
73 | # group = models.CharField(max_length=100)
74 | # service_name = models.CharField(max_length=100)
75 | # description = models.TextField()
76 |
77 | # city = models.ForeignKey('City')
78 | # street = models.ForeignKey('Street')
79 |
80 | class City(models.Model):
81 | """
82 |
83 | Give an ID to each city so everything can relate.
84 |
85 | """
86 | name = models.CharField(max_length=100)
87 | short_name = models.CharField(max_length=50)
88 | api_key = models.CharField(max_length=255, blank=True, null=True)
89 | url = models.CharField(max_length=255)
90 | jurisdiction_id = models.CharField(max_length=100)
91 | paginated = models.BooleanField()
92 |
93 | def natural_key(self):
94 | return self.name
95 |
96 | if ENABLE_GEO is True:
97 | class Geography(models.Model):
98 | """
99 |
100 | You can import any geographical shapes you want here and associate them
101 | with a city.
102 |
103 | """
104 | name = models.CharField(max_length=25)
105 | geo = models.MultiPolygonField(srid=900913)
106 |
107 | city = models.ForeignKey('City')
108 | #geo_type = models.ForeignKey('GeographyType')
109 |
110 | objects = models.GeoManager()
111 |
112 | def __unicode__(self):
113 | return self.name
114 |
115 | def get_absolute_url(self):
116 | return "/neighborhood/%i/" % self.id
117 |
118 | # class GeographyType(models.Model):
119 | """
120 |
121 | Ex: Neighborhood, Congressional Districts...
122 |
123 | """
124 | # name = models.CharField(max_length=25)
125 |
126 | # Thank @ravoreyer for recommending this.
127 | # city = models.ForeignKey('City')
128 |
129 | class Street(models.Model):
130 | """
131 |
132 | Street centerline data.
133 |
134 | """
135 | street_name = models.CharField(max_length=100)
136 | line = models.LineStringField(srid=900913)
137 | city = models.ForeignKey("City")
138 |
139 | left_low_address = models.IntegerField(default=0)
140 | left_high_address = models.IntegerField(default=0)
141 | right_low_address = models.IntegerField(default=0)
142 | right_high_address = models.IntegerField(default=0)
143 |
144 | objects = models.GeoManager()
145 |
146 | def __unicode__(self):
147 | return self.street_name
148 |
149 | def natural_key(self):
150 | return self.street_name
151 |
152 | def get_absolute_url(self):
153 | return "/street/%i/" % self.id
154 |
--------------------------------------------------------------------------------
/dashboard/scripts/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeforamerica/open311dashboard/891229ac922f8032d90658e0eef10562e79df622/dashboard/scripts/__init__.py
--------------------------------------------------------------------------------
/dashboard/scripts/bounding_box.py:
--------------------------------------------------------------------------------
1 | def create_bounding_box(points):
2 | #initialize
3 | lon_init = points[0]['lon']
4 | lat_init = points[0]['lat']
5 |
6 | minLon = lon_init
7 | maxLon = lon_init
8 | minLat = lat_init
9 | maxLat = lat_init
10 |
11 | for i in xrange(1,len(points)):
12 | if minLon > points[i]['lon']:
13 | minLon = points[i]['lon']
14 | if maxLon < points[i]['lon']:
15 | maxLon = points[i]['lon']
16 | if minLat > points[i]['lat']:
17 | minLat = points[i]['lat']
18 | if maxLat < points[i]['lat']:
19 | maxLat = points[i]['lat']
20 |
21 | bounding_box = [{'lat':minLat,'lon':minLon},{'lat':maxLat,'lon':maxLon}]
22 | print bounding_box
23 | return bounding_box
24 |
25 | if __name__ == 'main':
26 | #Create array of test points
27 | points = [{'lat': 37.77017,'lon':-122.41996},{'lat': 37.77559,'lon':-122.41516},{'lat':37.77858,'lon':-122.42614}]
28 | create_bounding_box(points)
--------------------------------------------------------------------------------
/dashboard/scripts/calculate_centroid.py:
--------------------------------------------------------------------------------
1 | from sys import argv
2 | import urllib
3 | import json as simplejson
4 | #2-D approximation
5 | def compute_area_of_polygon(polygon_points):
6 | area = 0
7 | num_of_vertices = len(polygon_points)
8 | j = num_of_vertices - 1
9 |
10 | for i in xrange(num_of_vertices):
11 | point1 = polygon_points[i]
12 | point2 = polygon_points[j]
13 |
14 | area = area + point1[0]*point2[1]
15 | area = area - point1[1]*point2[0]
16 |
17 | j = i
18 |
19 | area = .5 * area
20 |
21 | return area
22 |
23 | def compute_centroid(polygon_points):
24 | num_of_vertices = len(polygon_points)
25 | j = num_of_vertices - 1
26 | x = 0
27 | y = 0
28 |
29 | for i in xrange(num_of_vertices):
30 | point1 = polygon_points[i]
31 | point2 = polygon_points[j]
32 |
33 | diff = point1[0]*point2[1] - point2[0]*point1[1]
34 |
35 | x = x + diff * (point1[0]+point2[0])
36 | y = y + diff * (point1[1]+point2[1])
37 |
38 | j = i
39 |
40 | factor = 6 * compute_area_of_polygon(polygon_points)
41 |
42 | centroid = [x/factor,y/factor]
43 |
44 | print 'The centroid of the polygon is', centroid
45 |
46 | return centroid
47 |
48 | if __name__ == '__main__':
49 | script,input_file = argv
50 |
51 | geojson_url = input_file
52 | geojson = simplejson.load(urllib.urlopen(geojson_url))
53 |
54 | for i in xrange(len(geojson['features'])):
55 | print i
56 | if len(geojson['features'][i]['geometry']['coordinates'][0]) > 1:
57 | polygon_points = geojson['features'][i]['geometry']['coordinates'][0]
58 | else:
59 | polygon_points = geojson['features'][i]['geometry']['coordinates'][0][0]
60 |
61 | compute_centroid(polygon_points)
62 |
63 |
64 |
65 |
--------------------------------------------------------------------------------
/dashboard/scripts/extract_and_upload.py:
--------------------------------------------------------------------------------
1 | import os
2 | import sqlite3
3 |
4 | import boto
5 | import sys
6 | from boto.s3.key import Key
7 |
8 | #Use this if you want to use the create_bucket method
9 | #from boto import s3
10 |
11 | def percent_cb(complete, total):
12 | sys.stdout.write('.')
13 | sys.stdout.flush()
14 |
15 | def extract_tiles():
16 | """
17 | Shoutout to @rosskarchner: https://gist.github.com/837851
18 | Extracting images out of mbtiles. Creating folders and filenames.
19 | Works with mbtiles exported out of TileMill 0.4.2.
20 | """
21 |
22 | #Connect to the database
23 | connection = sqlite3.connect('census_blocks.mbtiles')
24 |
25 | #Get everything out of the flat file
26 | pieces = connection.execute('select * from tiles').fetchall()
27 |
28 | for piece in pieces:
29 | #the image is a png
30 | zoom_level, row, column, image = piece
31 |
32 | try:
33 | os.makedirs('%s/%s/' % (zoom_level,row))
34 | except:
35 | pass
36 | tile = open('%s/%s/%s.png' % (zoom_level, row, column), 'wb')
37 | tile.write(image)
38 | tile.close()
39 |
40 | if to_upload:
41 | upload_to_s3()
42 |
43 | def upload_to_s3():
44 | """
45 | Assists you in uploading a set of directories/files to S3. Assumes that your S3 bucket
46 | has already been created. Use the boto's create_bucket method if you don't have an existing bucket.
47 | """
48 | AWS_ACCESS_KEY_ID = 'Your AWS Access Key ID'
49 | AWS_SECRET_ACCESS_KEY = 'Your AWS Secret Access Key'
50 |
51 | #This is for making an extremely unique bucket name.
52 | #bucket_name = AWS_ACCESS_KEY_ID.lower() + 'Your desired bucket name'
53 |
54 | bucket_name = 'Your existing bucket name'
55 |
56 | #We connect!
57 | conn = boto.connect_s3(AWS_ACCESS_KEY_ID,AWS_SECRET_ACCESS_KEY)
58 |
59 | #Use this if you want to create a bucket
60 | #bucket = conn.create_bucket(bucket_name,location=s3.connection.Location.DEFAULT)
61 |
62 | #Connect to our existing bucket
63 | bucket = conn.get_bucket(bucket_name)
64 |
65 | #the base directory
66 | directory = 'base-directory'
67 |
68 | k = Key(bucket)
69 |
70 | for root, dirs, files in os.walk(directory):
71 | for f in files:
72 | print 'Uploading %s/%s to Amazon bucket %s' % (root, f, bucket_name)
73 |
74 | file_name = root + '/' + f
75 |
76 | k.key = file_name
77 | k.set_contents_from_filename(file_name,cb=percent_cb,num_cb=10)
78 |
79 | if __name__ == '__main__':
80 | """
81 | Pass is in Boolean variable on the command line to specify whether you want to upload your tiles to Amazon S3.
82 | to_upload is a Boolean variable.
83 | """
84 | script,to_upload = argv
85 | extract_tiles()
86 |
87 |
--------------------------------------------------------------------------------
/dashboard/scripts/extract_tiles.py:
--------------------------------------------------------------------------------
1 | import os
2 | import sqlite3
3 |
4 | mbtiles_filename = 'filename.mbtiles'
5 |
6 | def extract_tiles():
7 | """
8 | Shoutout to @rosskarchner: https://gist.github.com/837851
9 | Extracting images out of mbtiles. Creating folders and filenames.
10 | Works with mbtiles exported out of TileMill v0.4.2.
11 | """
12 |
13 | #Connect to the database
14 | connection = sqlite3.connect(mbtiles_filename)
15 |
16 | #Get everything out of the flat file
17 | pieces = connection.execute('select * from tiles').fetchall()
18 |
19 | for piece in pieces:
20 | #the image is a png
21 | zoom_level, row, column, image = piece
22 |
23 | try:
24 | os.makedirs('%s/%s/' % (zoom_level,row))
25 | except:
26 | pass
27 | tile = open('%s/%s/%s.png' % (zoom_level, row, column), 'wb')
28 | tile.write(image)
29 | tile.close()
30 |
31 | extract_tiles()
32 |
33 |
34 |
--------------------------------------------------------------------------------
/dashboard/scripts/heatmap_blocks.py:
--------------------------------------------------------------------------------
1 | import urllib
2 | import json as simplejson
3 | import math
4 | import pprint
5 |
6 | service_requests_url = 'input/service_requests.json'
7 | blocks_url = 'input/sf_blocks.json'
8 |
9 | #def compute_rect_bounds():
10 |
11 | def inside_rect_bounds(polygon_bounds,request_location):
12 |
13 | #initialize
14 | lon_init = polygon_bounds[0][0][0]
15 | lat_init = polygon_bounds[0][0][1]
16 |
17 | minLon = lon_init
18 | maxLon = lon_init
19 | minLat = lat_init
20 | maxLat = lat_init
21 |
22 | request_lat = request_location[0]
23 | request_lon = request_location[1]
24 |
25 | for i in xrange(1,len(polygon_bounds[0])):
26 | if minLon > polygon_bounds[0][i][0]:
27 | minLon = polygon_bounds[0][i][0]
28 | if maxLon < polygon_bounds[0][i][0]:
29 | maxLon = polygon_bounds[0][i][0]
30 | if minLat > polygon_bounds[0][i][1]:
31 | minLat = polygon_bounds[0][i][1]
32 | if maxLat < polygon_bounds[0][i][1]:
33 | maxLat = polygon_bounds[0][i][1]
34 |
35 | #rect_bounds = [minLon,maxLon,minLat,maxLat]
36 | if request_lat >= minLat and request_lat <= maxLat and request_lon >= minLon and request_lon <= maxLon:
37 | return True
38 | else:
39 | return False
40 |
41 | def inside_polygon(polygon_bounds,request_location):
42 | #polygon_bounds is an array
43 | #request_location is an array, lat/long
44 | request_lat = request_location[0]
45 | request_lon = request_location[1]
46 |
47 | vertices_count = len(polygon_bounds[0])
48 | inside = False
49 | #i = 0
50 | j = vertices_count - 1
51 |
52 | if inside_rect_bounds(polygon_bounds,request_location) == False:
53 | return False
54 | else:
55 | for i in xrange(vertices_count):
56 | vertexA = polygon_bounds[0][i]
57 | vertexB = polygon_bounds[0][j]
58 |
59 | if (vertexA[0] < request_lon and vertexB[0] >= request_lon) or (vertexB[0] < request_lon and vertexA[0] >= request_lon):
60 | if vertexA[1] + (((request_lon - vertexA[0]) / (vertexB[0] - vertexA[0])) * (vertexB[1] - vertexA[1])) < request_lat:
61 | inside = not inside
62 | j = i
63 | return inside
64 |
65 | #load in data
66 | service_requests = simplejson.load(urllib.urlopen(service_requests_url))
67 | blocks = simplejson.load(urllib.urlopen(blocks_url))
68 |
69 | #block_totals = [] #maps to 7386 blocks
70 | block_totals = [0]*len(blocks["features"])
71 |
72 | for i in xrange(len(service_requests["rows"])):
73 | print i
74 | request_lat = service_requests["rows"][i]["value"]["lat"]
75 | request_lon = service_requests["rows"][i]["value"]["long"]
76 | request_location = [float(request_lat),float(request_lon)]
77 |
78 | #print request_location
79 |
80 | if math.fabs(request_location[0]) != 0 or math.fabs(request_location[1]) != 0:
81 | for j in xrange(len(blocks["features"])):
82 | polygon_bounds = blocks["features"][j]["geometry"]["coordinates"]
83 |
84 | if inside_polygon(polygon_bounds,request_location) == True:
85 | block_totals[j] = block_totals[j] + 1
86 | else:
87 | continue
88 | #print block_totals
89 |
90 | print 'block_totals: ', block_totals
91 |
92 | for i in xrange(len(block_totals)):
93 | blocks["features"][i]["properties"]["count"] = block_totals[i]
94 |
95 | f = open('output/block_with_counts.json','w')
96 | simplejson.dump(blocks,f)
97 | f.close()
--------------------------------------------------------------------------------
/dashboard/scripts/heatmap_blocks_amazon.py:
--------------------------------------------------------------------------------
1 | #works!
2 | import urllib
3 | import json as simplejson
4 | import math
5 | import pprint
6 | import psycopg2 as pg
7 |
8 | service_requests_url = 'input/service_requests.json'
9 | blocks_url = 'input/sf_blocks.json'
10 |
11 | def connect_with_amazon(**kwargs):
12 | conn = pg.connect(**kwargs)
13 | cursor = conn.cursor()
14 | cursor.execute("""select lat, long from dashboard_request where lat > 0 and
15 | requested_datetime > '12-31-2010'""")
16 |
17 | return cursor.fetchall() #returns a list
18 | #def compute_rect_bounds():
19 |
20 | def inside_rect_bounds(polygon_bounds,request_location):
21 |
22 | #initialize
23 | lon_init = polygon_bounds[0][0][0]
24 | lat_init = polygon_bounds[0][0][1]
25 |
26 | minLon = lon_init
27 | maxLon = lon_init
28 | minLat = lat_init
29 | maxLat = lat_init
30 |
31 | request_lat = request_location[0]
32 | request_lon = request_location[1]
33 |
34 | for i in xrange(1,len(polygon_bounds[0])):
35 | if minLon > polygon_bounds[0][i][0]:
36 | minLon = polygon_bounds[0][i][0]
37 | if maxLon < polygon_bounds[0][i][0]:
38 | maxLon = polygon_bounds[0][i][0]
39 | if minLat > polygon_bounds[0][i][1]:
40 | minLat = polygon_bounds[0][i][1]
41 | if maxLat < polygon_bounds[0][i][1]:
42 | maxLat = polygon_bounds[0][i][1]
43 |
44 | #rect_bounds = [minLon,maxLon,minLat,maxLat]
45 | if request_lat >= minLat and request_lat <= maxLat and request_lon >= minLon and request_lon <= maxLon:
46 | return True
47 | else:
48 | return False
49 |
50 | def inside_polygon(polygon_bounds,request_location):
51 | #polygon_bounds is an array
52 | #request_location is an array, lat/long
53 | request_lat = request_location[0]
54 | request_lon = request_location[1]
55 |
56 | vertices_count = len(polygon_bounds[0])
57 | inside = False
58 | #i = 0
59 | j = vertices_count - 1
60 |
61 | if inside_rect_bounds(polygon_bounds,request_location) == False:
62 | return False
63 | else:
64 | for i in xrange(vertices_count):
65 | vertexA = polygon_bounds[0][i]
66 | vertexB = polygon_bounds[0][j]
67 |
68 | if (vertexA[0] < request_lon and vertexB[0] >= request_lon) or (vertexB[0] < request_lon and vertexA[0] >= request_lon):
69 | if vertexA[1] + (((request_lon - vertexA[0]) / (vertexB[0] - vertexA[0])) * (vertexB[1] - vertexA[1])) < request_lat:
70 | inside = not inside
71 | j = i
72 | return inside
73 |
74 | #load in data
75 | #service_requests = simplejson.load(urllib.urlopen(service_requests_url))
76 | service_requests = connect_with_amazon(host='', database='', user='',password='')
77 | print service_requests[0][0]
78 |
79 | blocks = simplejson.load(urllib.urlopen(blocks_url))
80 |
81 | #block_totals = [] #maps to 7386 blocks
82 | block_totals = [0]*len(blocks["features"])
83 |
84 | for i in xrange(len(service_requests)):
85 | print i
86 | request_lat = service_requests[i][0]
87 | print request_lat
88 | request_lon = service_requests[i][1]
89 | request_location = [float(request_lat),float(request_lon)]
90 |
91 | #print request_location
92 |
93 | if math.fabs(request_location[0]) != 0 or math.fabs(request_location[1]) != 0:
94 | for j in xrange(len(blocks["features"])):
95 | polygon_bounds = blocks["features"][j]["geometry"]["coordinates"]
96 |
97 | if inside_polygon(polygon_bounds,request_location) == True:
98 | block_totals[j] = block_totals[j] + 1
99 | else:
100 | continue
101 | #print block_totals
102 |
103 | print 'block_totals: ', block_totals
104 |
105 | for i in xrange(len(block_totals)):
106 | blocks["features"][i]["properties"]["count"] = block_totals[i]
107 |
108 | f = open('output/block_with_counts_pg.json','w')
109 | simplejson.dump(blocks,f)
110 | f.close()
111 |
--------------------------------------------------------------------------------
/dashboard/scripts/input/ReadMe:
--------------------------------------------------------------------------------
1 | Fixtures live here. To be added soon!
2 |
--------------------------------------------------------------------------------
/dashboard/scripts/nearest_street.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | import urllib
4 | import json as simplejson
5 | import pprint
6 | import math
7 |
8 | service_requests_url = 'input/service_requests.json'
9 | centerlines_url = 'input/centerlines.json'
10 |
11 | def lat_long_to_x_y(lat,lng):
12 | """Returns an array, a lng/lat pair that has been converted to x and y"""
13 | pair = []
14 | sinLat = math.sin((lat*math.pi)/180.0)
15 |
16 | x = ((lng+180.0)/360.0)
17 | y = (.5 - math.log((1.0 + sinLat)/(1.0 - sinLat)) / (4.0*math.pi))
18 |
19 | pair.append(x)
20 | pair.append(y)
21 |
22 | return pair
23 |
24 | """
25 | Duplicating function: to be fixed later
26 | """
27 | def lat_long_to_x_y_list(lng_lat):
28 | pair = []
29 | sinLat = math.sin((lng_lat[1]*math.pi)/180.0)
30 |
31 | x = ((lng_lat[0]+180.0)/360.0)
32 | y = (.5 - math.log((1.0 + sinLat)/(1.0 - sinLat)) / (4.0*math.pi))
33 |
34 | pair.append(x)
35 | pair.append(y)
36 | #print(lng_lat[1], lng_lat[0]);
37 | return pair
38 |
39 | def dot_product(v1,v2):
40 | """
41 | Take the dot product of two vectors; v1 and v2 are arrays.
42 | """
43 | return v1[0] * v2[0] + v1[1] * v2[1]
44 |
45 | """
46 | Optimizations
47 | TODO: Coarse Grid
48 | Precompute everything for a given segment, save time by computing information about a segment once, instead of everytime you use a segment
49 | Can take out square roots
50 | """
51 | def compute_distance(incident_x_y, segment_start, segment_end):
52 | deltaX_btwn_endpoints = segment_end[0] - segment_start[0]
53 | deltaY_btwn_endpoints = segment_end[1] - segment_start[1]
54 |
55 | segment_deltas = [deltaX_btwn_endpoints,deltaY_btwn_endpoints]
56 |
57 | deltaX_btwn_incident_and_segment_start = incident_x_y[0] - segment_start[0]
58 | deltaY_btwn_incident_and_segment_start = incident_x_y[1] - segment_start[1]
59 |
60 | incident_start_deltas = [deltaX_btwn_incident_and_segment_start, deltaY_btwn_incident_and_segment_start]
61 |
62 | """
63 | t is a parameter of the line segment. We compute the value of t, where the incident point orthogonally projects to the extended line segment.
64 | If t is less than 0, it projects before the startpoint. If t is greater than 1, it projects after the endpoint. Otherwise, it projects interior to
65 | the line segment.
66 | """
67 | t = dot_product(segment_deltas,incident_start_deltas)
68 |
69 | if t <= 0:
70 | #startpoint is closest to incident point
71 | return math.sqrt(dot_product(incident_start_deltas, incident_start_deltas))
72 | #return dot_product(incident_start_deltas, incident_start_deltas)
73 |
74 | squared_length_of_segment_deltas = dot_product(segment_deltas,segment_deltas)
75 |
76 | if t >= squared_length_of_segment_deltas:
77 | #endpoint is closest to incident point
78 |
79 | """
80 | compute incident_end_deltas
81 | """
82 | deltaX_btwn_incident_and_segment_end = incident_x_y[0] - segment_end[0]
83 | deltaY_btwn_incident_and_segment_end = incident_x_y[1] - segment_end[1]
84 |
85 | incident_end_deltas = [deltaX_btwn_incident_and_segment_end,deltaY_btwn_incident_and_segment_end]
86 |
87 | return math.sqrt(dot_product(incident_end_deltas,incident_end_deltas))
88 | #return dot_product(incident_end_deltas,incident_end_deltas)
89 | """
90 | closest point is interior to segment
91 | """
92 | interior_closest = dot_product(incident_start_deltas,incident_start_deltas) - ((t*t)/squared_length_of_segment_deltas)
93 | if interior_closest < 0:
94 | return 0
95 | else:
96 | return math.sqrt(interior_closest)
97 | #return dot_product(incident_start_deltas,incident_start_deltas) - ((t*t)/squared_length_of_segment_deltas)
98 |
99 |
100 | def process_data():
101 | service_requests = simplejson.load(urllib.urlopen(service_requests_url))
102 | centerlines = simplejson.load(urllib.urlopen(centerlines_url))
103 | #print(len(centerlines["features"]))
104 |
105 | service_requests_x_y = []
106 | month_list = []
107 | request_list = []
108 |
109 | for i in range(len(service_requests["rows"])):
110 | lat = float(service_requests["rows"][i]["value"]["lat"])
111 | lng = float(service_requests["rows"][i]["value"]["long"])
112 |
113 | if lat != 0.0 and lng != 0.0:
114 | service_requests_x_y.append(lat_long_to_x_y(lat,lng))
115 |
116 | line_segments = []
117 |
118 | for i in range(len(centerlines["features"])):
119 | sub_segments = centerlines["features"][i]["geometry"]["coordinates"]
120 | line_segments.append(sub_segments)
121 |
122 | line_segments_x_y = []
123 | for i in range(len(line_segments)):
124 | line_segments_x_y.append(map(lat_long_to_x_y_list, line_segments[i]))
125 |
126 | street_index = 0
127 | response_time_average = [0] * len(line_segments_x_y)
128 | response_time_sum = [0] * len(line_segments_x_y)
129 | street_count = [0] * len(line_segments_x_y)
130 |
131 | for i in range(len(service_requests_x_y)-41000):
132 | print i
133 | distance = 200;
134 | for j in range(len(line_segments_x_y)):
135 | for k in range(len(line_segments_x_y[j])-1):
136 | computed_distance = compute_distance(service_requests_x_y[i],line_segments_x_y[j][k],line_segments_x_y[j][k+1])
137 | if (distance > computed_distance):
138 | distance = computed_distance
139 | street_index = j
140 |
141 |
142 | #requests_by_street[street_index].append(request_list[i])
143 |
144 | street_count[street_index] = street_count[street_index] + 1
145 | print street_count
146 | max_count_list = []
147 |
148 | maximum = 0
149 |
150 | individual_counts = []
151 |
152 | maximum = max(street_count)
153 | normalized_street_scores = map(lambda x: 100*math.log((1024/maximum)*x,2) if x > 0 else x,street_count)
154 | #sub_centerlines = {"type": "FeatureCollection","features":[]}
155 | for i in range(len(centerlines["features"])):
156 | centerlines["features"][i]["properties"]["score"] = street_count[i] #either or
157 | #centerlines["features"][i]["properties"]["score"] = normalized_street_scores[i]
158 |
159 | #print "sub_centerlines length: ",len(sub_centerlines["features"])
160 |
161 |
162 | #f = open('output/scored_centerlines_sub_final.json','w')
163 | #simplejson.dump(sub_centerlines,f)
164 | #f.close()
165 | f2 = open('output/scored_centerlines_final.json','w')
166 | simplejson.dump(centerlines,f2)
167 | f2.close()
168 | process_data()
--------------------------------------------------------------------------------
/dashboard/scripts/upload_to_s3.py:
--------------------------------------------------------------------------------
1 | #Authors: Michael Lawrence Evans + Joanne Cheng
2 | import os
3 | import sys
4 | import boto
5 | from boto.s3.key import Key
6 |
7 | #Use this if you want to use the create_bucket method
8 | #from boto import s3
9 |
10 | def percent_cb(complete, total):
11 | """Command line updates."""
12 | sys.stdout.write('.')
13 | sys.stdout.flush()
14 |
15 | def upload_to_s3():
16 | AWS_ACCESS_KEY_ID = 'Your AWS Access Key ID'
17 | AWS_SECRET_ACCESS_KEY = 'Your AWS Secret Access Key'
18 |
19 | #This is for making an extremely unique bucket name.
20 | #bucket_name = AWS_ACCESS_KEY_ID.lower() + 'Your desired bucket name'
21 |
22 | bucket_name = 'Your existing bucket name'
23 |
24 | #We connect!
25 | conn = boto.connect_s3(AWS_ACCESS_KEY_ID,AWS_SECRET_ACCESS_KEY)
26 |
27 | #Use this if you want to create a bucket
28 | #bucket = conn.create_bucket(bucket_name,location=s3.connection.Location.DEFAULT)
29 |
30 | #Connect to our existing bucket
31 | bucket = conn.get_bucket(bucket_name)
32 |
33 | #the base directory
34 | directory = 'base-directory'
35 |
36 | k = Key(bucket)
37 |
38 | for root, dirs, files in os.walk(directory):
39 | for f in files:
40 | print 'Uploading %s/%s to Amazon bucket %s' % (root, f, bucket_name) #debugging
41 |
42 | file_name = root + '/' + f
43 |
44 | k.key = file_name
45 | k.set_contents_from_filename(file_name,cb=percent_cb,num_cb=10)
46 |
47 | upload_to_s3()
--------------------------------------------------------------------------------
/dashboard/static/chosen-sprite.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeforamerica/open311dashboard/891229ac922f8032d90658e0eef10562e79df622/dashboard/static/chosen-sprite.png
--------------------------------------------------------------------------------
/dashboard/static/css/960.css:
--------------------------------------------------------------------------------
1 | /*
2 | 960 Grid System ~ Core CSS.
3 | Learn more ~ http://960.gs/
4 |
5 | Licensed under GPL and MIT.
6 | */
7 |
8 | /*
9 | Forces backgrounds to span full width,
10 | even if there is horizontal scrolling.
11 | Increase this if your layout is wider.
12 |
13 | Note: IE6 works fine without this fix.
14 | */
15 |
16 | body {
17 | min-width: 960px;
18 | }
19 |
20 | /* `Container
21 | ----------------------------------------------------------------------------------------------------*/
22 |
23 | .container_12,
24 | .container_16 {
25 | margin-left: auto;
26 | margin-right: auto;
27 | width: 960px;
28 | }
29 |
30 | /* `Grid >> Global
31 | ----------------------------------------------------------------------------------------------------*/
32 |
33 | .grid_1,
34 | .grid_2,
35 | .grid_3,
36 | .grid_4,
37 | .grid_5,
38 | .grid_6,
39 | .grid_7,
40 | .grid_8,
41 | .grid_9,
42 | .grid_10,
43 | .grid_11,
44 | .grid_12,
45 | .grid_13,
46 | .grid_14,
47 | .grid_15,
48 | .grid_16 {
49 | display: inline;
50 | float: left;
51 | margin-left: 10px;
52 | margin-right: 10px;
53 | }
54 |
55 | .push_1, .pull_1,
56 | .push_2, .pull_2,
57 | .push_3, .pull_3,
58 | .push_4, .pull_4,
59 | .push_5, .pull_5,
60 | .push_6, .pull_6,
61 | .push_7, .pull_7,
62 | .push_8, .pull_8,
63 | .push_9, .pull_9,
64 | .push_10, .pull_10,
65 | .push_11, .pull_11,
66 | .push_12, .pull_12,
67 | .push_13, .pull_13,
68 | .push_14, .pull_14,
69 | .push_15, .pull_15 {
70 | position: relative;
71 | }
72 |
73 | .container_12 .grid_3,
74 | .container_16 .grid_4 {
75 | width: 220px;
76 | }
77 |
78 | .container_12 .grid_6,
79 | .container_16 .grid_8 {
80 | width: 460px;
81 | }
82 |
83 | .container_12 .grid_9,
84 | .container_16 .grid_12 {
85 | width: 700px;
86 | }
87 |
88 | .container_12 .grid_12,
89 | .container_16 .grid_16 {
90 | width: 940px;
91 | }
92 |
93 | /* `Grid >> Children (Alpha ~ First, Omega ~ Last)
94 | ----------------------------------------------------------------------------------------------------*/
95 |
96 | .alpha {
97 | margin-left: 0;
98 | }
99 |
100 | .omega {
101 | margin-right: 0;
102 | }
103 |
104 | /* `Grid >> 12 Columns
105 | ----------------------------------------------------------------------------------------------------*/
106 |
107 | .container_12 .grid_1 {
108 | width: 60px;
109 | }
110 |
111 | .container_12 .grid_2 {
112 | width: 140px;
113 | }
114 |
115 | .container_12 .grid_4 {
116 | width: 300px;
117 | }
118 |
119 | .container_12 .grid_5 {
120 | width: 380px;
121 | }
122 |
123 | .container_12 .grid_7 {
124 | width: 540px;
125 | }
126 |
127 | .container_12 .grid_8 {
128 | width: 620px;
129 | }
130 |
131 | .container_12 .grid_10 {
132 | width: 780px;
133 | }
134 |
135 | .container_12 .grid_11 {
136 | width: 860px;
137 | }
138 |
139 | /* `Grid >> 16 Columns
140 | ----------------------------------------------------------------------------------------------------*/
141 |
142 | .container_16 .grid_1 {
143 | width: 40px;
144 | }
145 |
146 | .container_16 .grid_2 {
147 | width: 100px;
148 | }
149 |
150 | .container_16 .grid_3 {
151 | width: 160px;
152 | }
153 |
154 | .container_16 .grid_5 {
155 | width: 280px;
156 | }
157 |
158 | .container_16 .grid_6 {
159 | width: 340px;
160 | }
161 |
162 | .container_16 .grid_7 {
163 | width: 400px;
164 | }
165 |
166 | .container_16 .grid_9 {
167 | width: 520px;
168 | }
169 |
170 | .container_16 .grid_10 {
171 | width: 580px;
172 | }
173 |
174 | .container_16 .grid_11 {
175 | width: 640px;
176 | }
177 |
178 | .container_16 .grid_13 {
179 | width: 760px;
180 | }
181 |
182 | .container_16 .grid_14 {
183 | width: 820px;
184 | }
185 |
186 | .container_16 .grid_15 {
187 | width: 880px;
188 | }
189 |
190 | /* `Prefix Extra Space >> Global
191 | ----------------------------------------------------------------------------------------------------*/
192 |
193 | .container_12 .prefix_3,
194 | .container_16 .prefix_4 {
195 | padding-left: 240px;
196 | }
197 |
198 | .container_12 .prefix_6,
199 | .container_16 .prefix_8 {
200 | padding-left: 480px;
201 | }
202 |
203 | .container_12 .prefix_9,
204 | .container_16 .prefix_12 {
205 | padding-left: 720px;
206 | }
207 |
208 | /* `Prefix Extra Space >> 12 Columns
209 | ----------------------------------------------------------------------------------------------------*/
210 |
211 | .container_12 .prefix_1 {
212 | padding-left: 80px;
213 | }
214 |
215 | .container_12 .prefix_2 {
216 | padding-left: 160px;
217 | }
218 |
219 | .container_12 .prefix_4 {
220 | padding-left: 320px;
221 | }
222 |
223 | .container_12 .prefix_5 {
224 | padding-left: 400px;
225 | }
226 |
227 | .container_12 .prefix_7 {
228 | padding-left: 560px;
229 | }
230 |
231 | .container_12 .prefix_8 {
232 | padding-left: 640px;
233 | }
234 |
235 | .container_12 .prefix_10 {
236 | padding-left: 800px;
237 | }
238 |
239 | .container_12 .prefix_11 {
240 | padding-left: 880px;
241 | }
242 |
243 | /* `Prefix Extra Space >> 16 Columns
244 | ----------------------------------------------------------------------------------------------------*/
245 |
246 | .container_16 .prefix_1 {
247 | padding-left: 60px;
248 | }
249 |
250 | .container_16 .prefix_2 {
251 | padding-left: 120px;
252 | }
253 |
254 | .container_16 .prefix_3 {
255 | padding-left: 180px;
256 | }
257 |
258 | .container_16 .prefix_5 {
259 | padding-left: 300px;
260 | }
261 |
262 | .container_16 .prefix_6 {
263 | padding-left: 360px;
264 | }
265 |
266 | .container_16 .prefix_7 {
267 | padding-left: 420px;
268 | }
269 |
270 | .container_16 .prefix_9 {
271 | padding-left: 540px;
272 | }
273 |
274 | .container_16 .prefix_10 {
275 | padding-left: 600px;
276 | }
277 |
278 | .container_16 .prefix_11 {
279 | padding-left: 660px;
280 | }
281 |
282 | .container_16 .prefix_13 {
283 | padding-left: 780px;
284 | }
285 |
286 | .container_16 .prefix_14 {
287 | padding-left: 840px;
288 | }
289 |
290 | .container_16 .prefix_15 {
291 | padding-left: 900px;
292 | }
293 |
294 | /* `Suffix Extra Space >> Global
295 | ----------------------------------------------------------------------------------------------------*/
296 |
297 | .container_12 .suffix_3,
298 | .container_16 .suffix_4 {
299 | padding-right: 240px;
300 | }
301 |
302 | .container_12 .suffix_6,
303 | .container_16 .suffix_8 {
304 | padding-right: 480px;
305 | }
306 |
307 | .container_12 .suffix_9,
308 | .container_16 .suffix_12 {
309 | padding-right: 720px;
310 | }
311 |
312 | /* `Suffix Extra Space >> 12 Columns
313 | ----------------------------------------------------------------------------------------------------*/
314 |
315 | .container_12 .suffix_1 {
316 | padding-right: 80px;
317 | }
318 |
319 | .container_12 .suffix_2 {
320 | padding-right: 160px;
321 | }
322 |
323 | .container_12 .suffix_4 {
324 | padding-right: 320px;
325 | }
326 |
327 | .container_12 .suffix_5 {
328 | padding-right: 400px;
329 | }
330 |
331 | .container_12 .suffix_7 {
332 | padding-right: 560px;
333 | }
334 |
335 | .container_12 .suffix_8 {
336 | padding-right: 640px;
337 | }
338 |
339 | .container_12 .suffix_10 {
340 | padding-right: 800px;
341 | }
342 |
343 | .container_12 .suffix_11 {
344 | padding-right: 880px;
345 | }
346 |
347 | /* `Suffix Extra Space >> 16 Columns
348 | ----------------------------------------------------------------------------------------------------*/
349 |
350 | .container_16 .suffix_1 {
351 | padding-right: 60px;
352 | }
353 |
354 | .container_16 .suffix_2 {
355 | padding-right: 120px;
356 | }
357 |
358 | .container_16 .suffix_3 {
359 | padding-right: 180px;
360 | }
361 |
362 | .container_16 .suffix_5 {
363 | padding-right: 300px;
364 | }
365 |
366 | .container_16 .suffix_6 {
367 | padding-right: 360px;
368 | }
369 |
370 | .container_16 .suffix_7 {
371 | padding-right: 420px;
372 | }
373 |
374 | .container_16 .suffix_9 {
375 | padding-right: 540px;
376 | }
377 |
378 | .container_16 .suffix_10 {
379 | padding-right: 600px;
380 | }
381 |
382 | .container_16 .suffix_11 {
383 | padding-right: 660px;
384 | }
385 |
386 | .container_16 .suffix_13 {
387 | padding-right: 780px;
388 | }
389 |
390 | .container_16 .suffix_14 {
391 | padding-right: 840px;
392 | }
393 |
394 | .container_16 .suffix_15 {
395 | padding-right: 900px;
396 | }
397 |
398 | /* `Push Space >> Global
399 | ----------------------------------------------------------------------------------------------------*/
400 |
401 | .container_12 .push_3,
402 | .container_16 .push_4 {
403 | left: 240px;
404 | }
405 |
406 | .container_12 .push_6,
407 | .container_16 .push_8 {
408 | left: 480px;
409 | }
410 |
411 | .container_12 .push_9,
412 | .container_16 .push_12 {
413 | left: 720px;
414 | }
415 |
416 | /* `Push Space >> 12 Columns
417 | ----------------------------------------------------------------------------------------------------*/
418 |
419 | .container_12 .push_1 {
420 | left: 80px;
421 | }
422 |
423 | .container_12 .push_2 {
424 | left: 160px;
425 | }
426 |
427 | .container_12 .push_4 {
428 | left: 320px;
429 | }
430 |
431 | .container_12 .push_5 {
432 | left: 400px;
433 | }
434 |
435 | .container_12 .push_7 {
436 | left: 560px;
437 | }
438 |
439 | .container_12 .push_8 {
440 | left: 640px;
441 | }
442 |
443 | .container_12 .push_10 {
444 | left: 800px;
445 | }
446 |
447 | .container_12 .push_11 {
448 | left: 880px;
449 | }
450 |
451 | /* `Push Space >> 16 Columns
452 | ----------------------------------------------------------------------------------------------------*/
453 |
454 | .container_16 .push_1 {
455 | left: 60px;
456 | }
457 |
458 | .container_16 .push_2 {
459 | left: 120px;
460 | }
461 |
462 | .container_16 .push_3 {
463 | left: 180px;
464 | }
465 |
466 | .container_16 .push_5 {
467 | left: 300px;
468 | }
469 |
470 | .container_16 .push_6 {
471 | left: 360px;
472 | }
473 |
474 | .container_16 .push_7 {
475 | left: 420px;
476 | }
477 |
478 | .container_16 .push_9 {
479 | left: 540px;
480 | }
481 |
482 | .container_16 .push_10 {
483 | left: 600px;
484 | }
485 |
486 | .container_16 .push_11 {
487 | left: 660px;
488 | }
489 |
490 | .container_16 .push_13 {
491 | left: 780px;
492 | }
493 |
494 | .container_16 .push_14 {
495 | left: 840px;
496 | }
497 |
498 | .container_16 .push_15 {
499 | left: 900px;
500 | }
501 |
502 | /* `Pull Space >> Global
503 | ----------------------------------------------------------------------------------------------------*/
504 |
505 | .container_12 .pull_3,
506 | .container_16 .pull_4 {
507 | left: -240px;
508 | }
509 |
510 | .container_12 .pull_6,
511 | .container_16 .pull_8 {
512 | left: -480px;
513 | }
514 |
515 | .container_12 .pull_9,
516 | .container_16 .pull_12 {
517 | left: -720px;
518 | }
519 |
520 | /* `Pull Space >> 12 Columns
521 | ----------------------------------------------------------------------------------------------------*/
522 |
523 | .container_12 .pull_1 {
524 | left: -80px;
525 | }
526 |
527 | .container_12 .pull_2 {
528 | left: -160px;
529 | }
530 |
531 | .container_12 .pull_4 {
532 | left: -320px;
533 | }
534 |
535 | .container_12 .pull_5 {
536 | left: -400px;
537 | }
538 |
539 | .container_12 .pull_7 {
540 | left: -560px;
541 | }
542 |
543 | .container_12 .pull_8 {
544 | left: -640px;
545 | }
546 |
547 | .container_12 .pull_10 {
548 | left: -800px;
549 | }
550 |
551 | .container_12 .pull_11 {
552 | left: -880px;
553 | }
554 |
555 | /* `Pull Space >> 16 Columns
556 | ----------------------------------------------------------------------------------------------------*/
557 |
558 | .container_16 .pull_1 {
559 | left: -60px;
560 | }
561 |
562 | .container_16 .pull_2 {
563 | left: -120px;
564 | }
565 |
566 | .container_16 .pull_3 {
567 | left: -180px;
568 | }
569 |
570 | .container_16 .pull_5 {
571 | left: -300px;
572 | }
573 |
574 | .container_16 .pull_6 {
575 | left: -360px;
576 | }
577 |
578 | .container_16 .pull_7 {
579 | left: -420px;
580 | }
581 |
582 | .container_16 .pull_9 {
583 | left: -540px;
584 | }
585 |
586 | .container_16 .pull_10 {
587 | left: -600px;
588 | }
589 |
590 | .container_16 .pull_11 {
591 | left: -660px;
592 | }
593 |
594 | .container_16 .pull_13 {
595 | left: -780px;
596 | }
597 |
598 | .container_16 .pull_14 {
599 | left: -840px;
600 | }
601 |
602 | .container_16 .pull_15 {
603 | left: -900px;
604 | }
605 |
606 | /* `Clear Floated Elements
607 | ----------------------------------------------------------------------------------------------------*/
608 |
609 | /* http://sonspring.com/journal/clearing-floats */
610 |
611 | .clear {
612 | clear: both;
613 | display: block;
614 | overflow: hidden;
615 | visibility: hidden;
616 | width: 0;
617 | height: 0;
618 | }
619 |
620 | /* http://www.yuiblog.com/blog/2010/09/27/clearfix-reloaded-overflowhidden-demystified */
621 |
622 | .clearfix:before,
623 | .clearfix:after,
624 | .container_12:before,
625 | .container_12:after,
626 | .container_16:before,
627 | .container_16:after {
628 | content: '.';
629 | display: block;
630 | overflow: hidden;
631 | visibility: hidden;
632 | font-size: 0;
633 | line-height: 0;
634 | width: 0;
635 | height: 0;
636 | }
637 |
638 | .clearfix:after,
639 | .container_12:after,
640 | .container_16:after {
641 | clear: both;
642 | }
643 |
644 | /*
645 | The following zoom:1 rule is specifically for IE6 + IE7.
646 | Move to separate stylesheet if invalid CSS is a problem.
647 | */
648 |
649 | .clearfix,
650 | .container_12,
651 | .container_16 {
652 | zoom: 1;
653 | }
--------------------------------------------------------------------------------
/dashboard/static/css/chosen.css:
--------------------------------------------------------------------------------
1 | /* @group Base */
2 | select.chzn-select {
3 | visibility: hidden;
4 | height: 28px !important;
5 | min-height: 28px !important;
6 | }
7 | .chzn-container {
8 | font-size: 13px;
9 | position: relative;
10 | display: inline-block;
11 | zoom: 1;
12 | *display: inline;
13 | }
14 | .chzn-container .chzn-drop {
15 | background: #fff;
16 | border: 1px solid #aaa;
17 | border-top: 0;
18 | position: absolute;
19 | top: 29px;
20 | left: 0;
21 | -webkit-box-shadow: 0 4px 5px rgba(0,0,0,.15);
22 | -moz-box-shadow : 0 4px 5px rgba(0,0,0,.15);
23 | -o-box-shadow : 0 4px 5px rgba(0,0,0,.15);
24 | box-shadow : 0 4px 5px rgba(0,0,0,.15);
25 | z-index: 999;
26 | }
27 | /* @end */
28 |
29 | /* @group Single Chosen */
30 | .chzn-container-single .chzn-single {
31 | background-color: #fff;
32 | background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #eeeeee), color-stop(0.5, white));
33 | background-image: -webkit-linear-gradient(center bottom, #eeeeee 0%, white 50%);
34 | background-image: -moz-linear-gradient(center bottom, #eeeeee 0%, white 50%);
35 | background-image: -o-linear-gradient(top, #eeeeee 0%,#ffffff 50%);
36 | background-image: -ms-linear-gradient(top, #eeeeee 0%,#ffffff 50%);
37 | filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#eeeeee', endColorstr='#ffffff',GradientType=0 );
38 | background-image: linear-gradient(top, #eeeeee 0%,#ffffff 50%);
39 | -webkit-border-radius: 4px;
40 | -moz-border-radius : 4px;
41 | border-radius : 4px;
42 | -moz-background-clip : padding;
43 | -webkit-background-clip: padding-box;
44 | background-clip : padding-box;
45 | border: 1px solid #aaa;
46 | display: block;
47 | overflow: hidden;
48 | white-space: nowrap;
49 | position: relative;
50 | height: 26px;
51 | line-height: 26px;
52 | padding: 0 0 0 8px;
53 | color: #444;
54 | text-decoration: none;
55 | }
56 | .chzn-container-single .chzn-single span {
57 | margin-right: 26px;
58 | display: block;
59 | overflow: hidden;
60 | white-space: nowrap;
61 | -o-text-overflow: ellipsis;
62 | -ms-text-overflow: ellipsis;
63 | -moz-binding: url('/xml/ellipsis.xml#ellipsis');
64 | text-overflow: ellipsis;
65 | }
66 | .chzn-container-single .chzn-single div {
67 | -webkit-border-radius: 0 4px 4px 0;
68 | -moz-border-radius : 0 4px 4px 0;
69 | border-radius : 0 4px 4px 0;
70 | -moz-background-clip : padding;
71 | -webkit-background-clip: padding-box;
72 | background-clip : padding-box;
73 | background: #ccc;
74 | background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #ccc), color-stop(0.6, #eee));
75 | background-image: -webkit-linear-gradient(center bottom, #ccc 0%, #eee 60%);
76 | background-image: -moz-linear-gradient(center bottom, #ccc 0%, #eee 60%);
77 | background-image: -o-linear-gradient(bottom, #ccc 0%, #eee 60%);
78 | background-image: -ms-linear-gradient(top, #cccccc 0%,#eeeeee 60%);
79 | filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#cccccc', endColorstr='#eeeeee',GradientType=0 );
80 | background-image: linear-gradient(top, #cccccc 0%,#eeeeee 60%);
81 | border-left: 1px solid #aaa;
82 | position: absolute;
83 | right: 0;
84 | top: 0;
85 | display: block;
86 | height: 100%;
87 | width: 18px;
88 | }
89 | .chzn-container-single .chzn-single div b {
90 | background: url('/static/chosen-sprite.png') no-repeat 0 1px;
91 | display: block;
92 | width: 100%;
93 | height: 100%;
94 | }
95 | .chzn-container-single .chzn-search {
96 | padding: 3px 4px;
97 | margin: 0;
98 | white-space: nowrap;
99 | }
100 | .chzn-container-single .chzn-search input {
101 | background: #fff url('/static/chosen-sprite.png') no-repeat 100% -20px;
102 | background: url('/static/chosen-sprite.png') no-repeat 100% -20px, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, white), color-stop(0.99, #eeeeee));
103 | background: url('/static/chosen-sprite.png') no-repeat 100% -20px, -webkit-linear-gradient(center bottom, white 85%, #eeeeee 99%);
104 | background: url('/static/chosen-sprite.png') no-repeat 100% -20px, -moz-linear-gradient(center bottom, white 85%, #eeeeee 99%);
105 | background: url('/static/chosen-sprite.png') no-repeat 100% -20px, -o-linear-gradient(bottom, white 85%, #eeeeee 99%);
106 | background: url('/static/chosen-sprite.png') no-repeat 100% -20px, -ms-linear-gradient(top, #ffffff 85%,#eeeeee 99%);
107 | background: url('/static/chosen-sprite.png') no-repeat 100% -20px, -ms-linear-gradient(top, #ffffff 85%,#eeeeee 99%);
108 | background: url('/static/chosen-sprite.png') no-repeat 100% -20px, linear-gradient(top, #ffffff 85%,#eeeeee 99%);
109 | margin: 1px 0;
110 | padding: 4px 20px 4px 5px;
111 | outline: 0;
112 | border: 1px solid #aaa;
113 | font-family: sans-serif;
114 | font-size: 1em;
115 | }
116 | .chzn-container-single .chzn-drop {
117 | -webkit-border-radius: 0 0 4px 4px;
118 | -moz-border-radius : 0 0 4px 4px;
119 | border-radius : 0 0 4px 4px;
120 | -moz-background-clip : padding;
121 | -webkit-background-clip: padding-box;
122 | background-clip : padding-box;
123 | }
124 | /* @end */
125 |
126 | /* @group Multi Chosen */
127 | .chzn-container-multi .chzn-choices {
128 | background-color: #fff;
129 | background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0.85, white), color-stop(0.99, #eeeeee));
130 | background-image: -webkit-linear-gradient(center bottom, white 85%, #eeeeee 99%);
131 | background-image: -moz-linear-gradient(center bottom, white 85%, #eeeeee 99%);
132 | background-image: -o-linear-gradient(bottom, white 85%, #eeeeee 99%);
133 | background-image: -ms-linear-gradient(top, #ffffff 85%,#eeeeee 99%);
134 | filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#ffffff', endColorstr='#eeeeee',GradientType=0 );
135 | background-image: linear-gradient(top, #ffffff 85%,#eeeeee 99%);
136 | border: 1px solid #aaa;
137 | margin: 0;
138 | padding: 0;
139 | cursor: text;
140 | overflow: hidden;
141 | height: auto !important;
142 | height: 1%;
143 | position: relative;
144 | }
145 | .chzn-container-multi .chzn-choices li {
146 | float: left;
147 | list-style: none;
148 | }
149 | .chzn-container-multi .chzn-choices .search-field {
150 | white-space: nowrap;
151 | margin: 0;
152 | padding: 0;
153 | }
154 | .chzn-container-multi .chzn-choices .search-field input {
155 | color: #666;
156 | background: transparent !important;
157 | border: 0 !important;
158 | padding: 5px;
159 | margin: 1px 0;
160 | outline: 0;
161 | -webkit-box-shadow: none;
162 | -moz-box-shadow : none;
163 | -o-box-shadow : none;
164 | box-shadow : none;
165 | }
166 | .chzn-container-multi .chzn-choices .search-field .default {
167 | color: #999;
168 | }
169 | .chzn-container-multi .chzn-choices .search-choice {
170 | -webkit-border-radius: 3px;
171 | -moz-border-radius : 3px;
172 | border-radius : 3px;
173 | -moz-background-clip : padding;
174 | -webkit-background-clip: padding-box;
175 | background-clip : padding-box;
176 | background-color: #e4e4e4;
177 | background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #e4e4e4), color-stop(0.7, #eeeeee));
178 | background-image: -webkit-linear-gradient(center bottom, #e4e4e4 0%, #eeeeee 70%);
179 | background-image: -moz-linear-gradient(center bottom, #e4e4e4 0%, #eeeeee 70%);
180 | background-image: -o-linear-gradient(bottom, #e4e4e4 0%, #eeeeee 70%);
181 | background-image: -ms-linear-gradient(top, #e4e4e4 0%,#eeeeee 70%);
182 | filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#e4e4e4', endColorstr='#eeeeee',GradientType=0 );
183 | background-image: linear-gradient(top, #e4e4e4 0%,#eeeeee 70%);
184 | color: #333;
185 | border: 1px solid #b4b4b4;
186 | line-height: 13px;
187 | padding: 3px 19px 3px 6px;
188 | margin: 3px 0 3px 5px;
189 | position: relative;
190 | }
191 | .chzn-container-multi .chzn-choices .search-choice span {
192 | cursor: default;
193 | }
194 | .chzn-container-multi .chzn-choices .search-choice-focus {
195 | background: #d4d4d4;
196 | }
197 | .chzn-container-multi .chzn-choices .search-choice .search-choice-close {
198 | display: block;
199 | position: absolute;
200 | right: 5px;
201 | top: 6px;
202 | width: 8px;
203 | height: 9px;
204 | font-size: 1px;
205 | background: url('/static/chosen-sprite.png') right top no-repeat;
206 | }
207 | .chzn-container-multi .chzn-choices .search-choice .search-choice-close:hover {
208 | background-position: right -9px;
209 | }
210 | .chzn-container-multi .chzn-choices .search-choice-focus .search-choice-close {
211 | background-position: right -9px;
212 | }
213 | /* @end */
214 |
215 | /* @group Results */
216 | .chzn-container .chzn-results {
217 | margin: 0 4px 4px 0;
218 | max-height: 190px;
219 | padding: 0 0 0 4px;
220 | position: relative;
221 | overflow-x: hidden;
222 | overflow-y: auto;
223 | }
224 | .chzn-container-multi .chzn-results {
225 | margin: -1px 0 0;
226 | padding: 0;
227 | }
228 | .chzn-container .chzn-results li {
229 | line-height: 80%;
230 | padding: 7px 7px 8px;
231 | margin: 0;
232 | list-style: none;
233 | }
234 | .chzn-container .chzn-results .active-result {
235 | cursor: pointer;
236 | }
237 | .chzn-container .chzn-results .highlighted {
238 | background: #3875d7;
239 | color: #fff;
240 | }
241 | .chzn-container .chzn-results li em {
242 | background: #feffde;
243 | font-style: normal;
244 | }
245 | .chzn-container .chzn-results .highlighted em {
246 | background: transparent;
247 | }
248 | .chzn-container .chzn-results .no-results {
249 | background: #f4f4f4;
250 | }
251 | .chzn-container .chzn-results .group-result {
252 | cursor: default;
253 | color: #999;
254 | font-weight: bold;
255 | }
256 | .chzn-container .chzn-results .group-option {
257 | padding-left: 20px;
258 | }
259 | .chzn-container-multi .chzn-drop .result-selected {
260 | display: none;
261 | }
262 | /* @end */
263 |
264 | /* @group Active */
265 | .chzn-container-active .chzn-single {
266 | -webkit-box-shadow: 0 0 5px rgba(0,0,0,.3);
267 | -moz-box-shadow : 0 0 5px rgba(0,0,0,.3);
268 | -o-box-shadow : 0 0 5px rgba(0,0,0,.3);
269 | box-shadow : 0 0 5px rgba(0,0,0,.3);
270 | border: 1px solid #5897fb;
271 | }
272 | .chzn-container-active .chzn-single-with-drop {
273 | border: 1px solid #aaa;
274 | -webkit-box-shadow: 0 1px 0 #fff inset;
275 | -moz-box-shadow : 0 1px 0 #fff inset;
276 | -o-box-shadow : 0 1px 0 #fff inset;
277 | box-shadow : 0 1px 0 #fff inset;
278 | background-color: #eee;
279 | background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, white), color-stop(0.5, #eeeeee));
280 | background-image: -webkit-linear-gradient(center bottom, white 0%, #eeeeee 50%);
281 | background-image: -moz-linear-gradient(center bottom, white 0%, #eeeeee 50%);
282 | background-image: -o-linear-gradient(bottom, white 0%, #eeeeee 50%);
283 | background-image: -ms-linear-gradient(top, #ffffff 0%,#eeeeee 50%);
284 | filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#ffffff', endColorstr='#eeeeee',GradientType=0 );
285 | background-image: linear-gradient(top, #ffffff 0%,#eeeeee 50%);
286 | -webkit-border-bottom-left-radius : 0;
287 | -webkit-border-bottom-right-radius: 0;
288 | -moz-border-radius-bottomleft : 0;
289 | -moz-border-radius-bottomright: 0;
290 | border-bottom-left-radius : 0;
291 | border-bottom-right-radius: 0;
292 | }
293 | .chzn-container-active .chzn-single-with-drop div {
294 | background: transparent;
295 | border-left: none;
296 | }
297 | .chzn-container-active .chzn-single-with-drop div b {
298 | background-position: -18px 1px;
299 | }
300 | .chzn-container-active .chzn-choices {
301 | -webkit-box-shadow: 0 0 5px rgba(0,0,0,.3);
302 | -moz-box-shadow : 0 0 5px rgba(0,0,0,.3);
303 | -o-box-shadow : 0 0 5px rgba(0,0,0,.3);
304 | box-shadow : 0 0 5px rgba(0,0,0,.3);
305 | border: 1px solid #5897fb;
306 | }
307 | .chzn-container-active .chzn-choices .search-field input {
308 | color: #111 !important;
309 | }
310 | /* @end */
311 |
312 | /* @group Right to Left */
313 | .chzn-rtl { direction:rtl;text-align: right; }
314 | .chzn-rtl .chzn-single { padding-left: 0; padding-right: 8px; }
315 | .chzn-rtl .chzn-single span { margin-left: 26px; margin-right: 0; }
316 | .chzn-rtl .chzn-single div {
317 | left: 0; right: auto;
318 | border-left: none; border-right: 1px solid #aaaaaa;
319 | -webkit-border-radius: 4px 0 0 4px;
320 | -moz-border-radius : 4px 0 0 4px;
321 | border-radius : 4px 0 0 4px;
322 | }
323 | .chzn-rtl .chzn-choices li { float: right; }
324 | .chzn-rtl .chzn-choices .search-choice { padding: 3px 6px 3px 19px; margin: 3px 5px 3px 0; }
325 | .chzn-rtl .chzn-choices .search-choice .search-choice-close { left: 5px; right: auto; background-position: right top;}
326 | .chzn-rtl.chzn-container-single .chzn-results { margin-left: 4px; margin-right: 0; padding-left: 0; padding-right: 4px; }
327 | .chzn-rtl .chzn-results .group-option { padding-left: 0; padding-right: 20px; }
328 | .chzn-rtl.chzn-container-active .chzn-single-with-drop div { border-right: none; }
329 | .chzn-rtl .chzn-search input {
330 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, #ffffff;
331 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, white), color-stop(0.99, #eeeeee));
332 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, -webkit-linear-gradient(center bottom, white 85%, #eeeeee 99%);
333 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, -moz-linear-gradient(center bottom, white 85%, #eeeeee 99%);
334 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, -o-linear-gradient(bottom, white 85%, #eeeeee 99%);
335 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, -ms-linear-gradient(top, #ffffff 85%,#eeeeee 99%);
336 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, -ms-linear-gradient(top, #ffffff 85%,#eeeeee 99%);
337 | background: url('/static/chosen-sprite.png') no-repeat -38px -20px, linear-gradient(top, #ffffff 85%,#eeeeee 99%);
338 | padding: 4px 5px 4px 20px;
339 | }
340 | /* @end */
341 |
--------------------------------------------------------------------------------
/dashboard/static/css/handheld.css:
--------------------------------------------------------------------------------
1 | * {
2 | float: none; /* Screens are not big enough to account for floats */
3 | background: #fff; /* As much contrast as possible */
4 | color: #000;
5 | }
6 |
7 | /* Slightly reducing font size to reduce need to scroll */
8 | body { font-size: 80%; }
--------------------------------------------------------------------------------
/dashboard/static/css/open311.css:
--------------------------------------------------------------------------------
1 | div.topbar-wrapper {
2 | position: relative;
3 | height: 40px;
4 | margin: 5px 0 15px;
5 | }
6 | div .topbar {
7 | background-color:black;
8 | margin: 0 -20px;
9 | padding-left: 20px;
10 | padding-right: 20px;
11 | -moz-border-radius: 4px;
12 | border-radius: 4px;
13 | }
14 |
15 | body{
16 | overflow:hidden;
17 | }
18 | .show-grid {
19 | margin-top: 20px;
20 | margin-bottom: 20px;
21 | }
22 | .show-grid .column, .show-grid .columns {
23 | text-align: center;
24 | -moz-border-radius: 3px;
25 | border-radius: 3px;
26 | }
27 | .search-select {
28 | color: #E6E6E6;
29 | background-color: darkGray;
30 | }
31 |
32 | #map{
33 | -moz-border-radius: 5px;
34 | border-radius: 5px;
35 | height: 500px;
36 | background-color: #DCEAF4;
37 | }
38 |
39 |
40 | .ui-autocomplete,.ui-corner-all{
41 | list-style-type: none;
42 | width: 250px;
43 | }
44 |
--------------------------------------------------------------------------------
/dashboard/static/css/street_view_styles.css:
--------------------------------------------------------------------------------
1 | /*CONTAINERS*/
2 |
3 | #nav {
4 | width: 990px;
5 | text-align: right;
6 | margin: 10px;
7 | }
8 |
9 | #map, #street-stats, #open-requests, #nearby {
10 | -moz-border-radius: 5px;
11 | -webkit-border-radius: 5px;
12 | border-radius: 5px;
13 | -khtml-border-radius: 5px;
14 | margin: 10px 0;
15 | width: 100%;
16 | float: left;
17 | background-color: white;
18 | padding-bottom:10px;
19 | }
20 |
21 | #map {
22 | height: 380px;
23 | padding-bottom:0px;
24 | }
25 |
26 | /*MAP*/
27 | #geometry path {
28 | stroke:#666;
29 | stroke-linecap:round;
30 | }
31 |
32 | .street path {
33 | fill:none;
34 | stroke-width:5px;
35 | }
36 |
37 | .neighborhood path {
38 | stroke-width:3px;
39 | fill:#fff;
40 | fill-opacity:.4;
41 | }
42 |
43 | /*STREET STATS*/
44 |
45 | #spark-line {
46 | width: 220px;
47 | height: 60px;
48 | background-color: white;
49 | margin: 10px auto;
50 | }
51 |
52 | #response-time {
53 | font-size: 32px;
54 | font-weight: bold;
55 | margin: 0;
56 | padding: 15px 0 0;
57 | text-align: center;
58 | }
59 |
60 | #top-requests .service-name {
61 | width:75%;
62 | }
63 |
64 | /*OPEN REQUESTS*/
65 | #open-requests p {
66 | text-align: right;
67 | }
68 |
69 | #open-requests table .service-name {
70 | width:75%;
71 | }
72 |
73 |
74 | /*NEARBY*/
75 |
76 | #nearby table td {
77 | background-color: white;
78 | padding: 8px 0;
79 | }
80 |
81 |
82 |
83 |
84 |
85 |
--------------------------------------------------------------------------------
/dashboard/static/css/style.css:
--------------------------------------------------------------------------------
1 | /**
2 | * HTML5 ✰ Boilerplate
3 | *
4 | * style.css contains a reset, font normalization and some base styles.
5 | *
6 | * Credit is left where credit is due.
7 | * Much inspiration was taken from these projects:
8 | * - yui.yahooapis.com/2.8.1/build/base/base.css
9 | * - camendesign.com/design/
10 | * - praegnanz.de/weblog/htmlcssjs-kickstart
11 | */
12 |
13 |
14 | /**
15 | * html5doctor.com Reset Stylesheet (Eric Meyer's Reset Reloaded + HTML5 baseline)
16 | * v1.6.1 2010-09-17 | Authors: Eric Meyer & Richard Clark
17 | * html5doctor.com/html-5-reset-stylesheet/
18 | */
19 |
20 | html, body, div, span, object, iframe,
21 | h1, h2, h3, h4, h5, h6, p, blockquote, pre,
22 | abbr, address, cite, code, del, dfn, em, img, ins, kbd, q, samp,
23 | small, strong, sub, sup, var, b, i, dl, dt, dd, ol, ul, li,
24 | fieldset, form, label, legend,
25 | table, caption, tbody, tfoot, thead, tr, th, td,
26 | article, aside, canvas, details, figcaption, figure,
27 | footer, header, hgroup, menu, nav, section, summary,
28 | time, mark, audio, video {
29 | margin: 0;
30 | padding: 0;
31 | border: 0;
32 | font-size: 100%;
33 | font: inherit;
34 | vertical-align: baseline;
35 | }
36 |
37 | article, aside, details, figcaption, figure,
38 | footer, header, hgroup, menu, nav, section {
39 | display: block;
40 | }
41 |
42 | blockquote, q { quotes: none; }
43 |
44 | blockquote:before, blockquote:after,
45 | q:before, q:after { content: ""; content: none; }
46 |
47 | ins { background-color: #ff9; color: #000; text-decoration: none; }
48 |
49 | mark { background-color: #ff9; color: #000; font-style: italic; font-weight: bold; }
50 |
51 | del { text-decoration: line-through; }
52 |
53 | abbr[title], dfn[title] { border-bottom: 1px dotted; cursor: help; }
54 |
55 | table { border-collapse: collapse; border-spacing: 0; }
56 |
57 | hr { display: block; height: 1px; border: 0; border-top: 1px solid #ccc; margin: 1em 0; padding: 0; }
58 |
59 | input, select { vertical-align: middle; }
60 |
61 |
62 | /**
63 | * Font normalization inspired by YUI Library's fonts.css: developer.yahoo.com/yui/
64 | */
65 |
66 | body { font:13px/1.231 sans-serif; *font-size:small; } /* Hack retained to preserve specificity */
67 | select, input, textarea, button { font:99% sans-serif; }
68 |
69 | /* Normalize monospace sizing:
70 | en.wikipedia.org/wiki/MediaWiki_talk:Common.css/Archive_11#Teletype_style_fix_for_Chrome */
71 | pre, code, kbd, samp { font-family: monospace, sans-serif; }
72 |
73 |
74 | /**
75 | * Minimal base styles.
76 | */
77 |
78 | /* Always force a scrollbar in non-IE */
79 | html { overflow-y: scroll; }
80 |
81 | /* Accessible focus treatment: people.opera.com/patrickl/experiments/keyboard/test */
82 | a:hover, a:active { outline: none; }
83 |
84 | ul, ol { margin-left: 2em; }
85 | ol { list-style-type: decimal; }
86 |
87 | /* Remove margins for navigation lists */
88 | nav ul, nav li { margin: 0; list-style:none; list-style-image: none; }
89 |
90 | small { font-size: 85%; }
91 | strong, th { font-weight: bold; }
92 |
93 | td { vertical-align: top; }
94 |
95 | /* Set sub, sup without affecting line-height: gist.github.com/413930 */
96 | sub, sup { font-size: 75%; line-height: 0; position: relative; }
97 | sup { top: -0.5em; }
98 | sub { bottom: -0.25em; }
99 |
100 | pre {
101 | /* www.pathf.com/blogs/2008/05/formatting-quoted-code-in-blog-posts-css21-white-space-pre-wrap/ */
102 | white-space: pre; white-space: pre-wrap; word-wrap: break-word;
103 | padding: 15px;
104 | }
105 |
106 | textarea { overflow: auto; } /* www.sitepoint.com/blogs/2010/08/20/ie-remove-textarea-scrollbars/ */
107 |
108 | .ie6 legend, .ie7 legend { margin-left: -7px; }
109 |
110 | /* Align checkboxes, radios, text inputs with their label by: Thierry Koblentz tjkdesign.com/ez-css/css/base.css */
111 | input[type="radio"] { vertical-align: text-bottom; }
112 | input[type="checkbox"] { vertical-align: bottom; }
113 | .ie7 input[type="checkbox"] { vertical-align: baseline; }
114 | .ie6 input { vertical-align: text-bottom; }
115 |
116 | /* Hand cursor on clickable input elements */
117 | label, input[type="button"], input[type="submit"], input[type="image"], button { cursor: pointer; }
118 |
119 | /* Webkit browsers add a 2px margin outside the chrome of form elements */
120 | button, input, select, textarea { margin: 0; }
121 |
122 | /* Colors for form validity */
123 | input:valid, textarea:valid { }
124 | input:invalid, textarea:invalid {
125 | border-radius: 1px; -moz-box-shadow: 0px 0px 5px red; -webkit-box-shadow: 0px 0px 5px red; box-shadow: 0px 0px 5px red;
126 | }
127 | .no-boxshadow input:invalid, .no-boxshadow textarea:invalid { background-color: #f0dddd; }
128 |
129 |
130 | /* These selection declarations have to be separate
131 | No text-shadow: twitter.com/miketaylr/status/12228805301
132 | Also: hot pink! */
133 | ::-moz-selection{ background: #FF5E99; color:#fff; text-shadow: none; }
134 | ::selection { background:#FF5E99; color:#fff; text-shadow: none; }
135 |
136 | /* j.mp/webkit-tap-highlight-color */
137 | a:link { -webkit-tap-highlight-color: #FF5E99; }
138 |
139 | /* Make buttons play nice in IE:
140 | www.viget.com/inspire/styling-the-button-element-in-internet-explorer/ */
141 | button { width: auto; overflow: visible; }
142 |
143 | /* Bicubic resizing for non-native sized IMG:
144 | code.flickr.com/blog/2008/11/12/on-ui-quality-the-little-things-client-side-image-resizing/ */
145 | .ie7 img { -ms-interpolation-mode: bicubic; }
146 |
147 | /**
148 | * You might tweak these..
149 | */
150 |
151 | body, select, input, textarea {
152 | /* #444 looks better than black: twitter.com/H_FJ/statuses/11800719859 */
153 | color: #444;
154 | /* Set your base font here, to apply evenly */
155 | /* font-family: Georgia, serif; */
156 | }
157 |
158 | /* Headers (h1, h2, etc) have no default font-size or margin; define those yourself */
159 | h1, h2, h3, h4, h5, h6 { font-weight: bold; }
160 |
161 | a, a:active, a:visited { color: #607890; }
162 | a:hover { color: #036; }
163 |
164 |
165 | /**
166 | * Primary styles
167 | *
168 | * Author: Chris Barna and mevans.
169 | */
170 | /*GENERAL STYLES*/
171 | body {
172 | font-family: helvetica;
173 | background-color: #EDEDED;
174 | }
175 |
176 | h1 {
177 | font-size: 18px;
178 | font-weight: bold;
179 | padding: 20px 10px;
180 | }
181 |
182 | h2 {
183 | font-size: 14px;
184 | text-align: center;
185 | padding: 5px;
186 | }
187 |
188 | p {
189 | font-size: 12px;
190 | padding: 5px;
191 | }
192 |
193 | .caption {
194 | text-align: center;
195 | font-style: italic;
196 | font-size: 14px;
197 | margin: 0 15px;
198 | display: block;
199 | border-bottom: 1px solid #EDEDED;
200 |
201 | }
202 |
203 | /*TABLES*/
204 |
205 | table {
206 | width: 90%;
207 | margin: 0 auto;
208 | font-size: 14px;
209 | }
210 |
211 | th {
212 | text-align: left;
213 | font-weight: bold;
214 | }
215 |
216 | td {
217 | padding: 5px 0;
218 | }
219 |
220 | tr {
221 | background-color: #fff;
222 | }
223 |
224 | tr:nth-child(2n) {
225 | background-color: #EDEDED;
226 | }
227 |
228 | #street-stats td:nth-child(2), #nearby td:nth-child(2) {
229 | text-align: right;
230 | }
231 |
232 | #container {
233 | min-width:960px;
234 | min-height:600px;
235 | height:100%;
236 | overflow:hidden;
237 | }
238 |
239 | #container header {
240 | background:#ccc;
241 | padding:5px 0px;
242 | }
243 |
244 | .border-radius {
245 | margin-top:10px;
246 | -moz-border-radius: 5px;
247 | -webkit-border-radius: 5px;
248 | border-radius: 5px;
249 | -khtml-border-radius: 5px;
250 | }
251 |
252 | .white {
253 | background-color:#fff;
254 | }
255 |
256 | #title {
257 | width:50%;
258 | float:left;
259 | }
260 |
261 | #title h1 { padding:0 5px; }
262 |
263 | #home-nav {
264 | width:49%;
265 | float:right;
266 | text-align:right;
267 | padding-top:8px;
268 | padding-right:1%;
269 | }
270 |
271 | #map {
272 | height:100%;
273 | }
274 |
275 | .chevron {
276 | stroke:#999;
277 | stroke-width:3px;
278 | fill:none;
279 | }
280 |
281 | .fore {
282 | stroke:#999;
283 | stroke-width:1.5px;
284 | }
285 | .back {
286 | fill:#eee;
287 | fill-opacity:.8;
288 | }
289 | .direction {
290 | fill:none;
291 | }
292 |
293 | #home-nav ul {
294 | margin:0;
295 | padding:0;
296 | padding-top:8px;
297 | list-style-type:none;
298 | }
299 |
300 | #home-nav li {
301 | float:right;
302 | margin-right:10px;
303 | }
304 |
305 | #home-nav a:link, #home-nav a:visited {
306 | font-weight:bold;
307 | text-decoration:none;
308 | padding-right:10px;
309 | }
310 |
311 | header h1 a:link, header h1 a:visited {
312 | text-decoration:none;
313 | }
314 |
315 | /* http://sonspring.com/journal/clearing-floats */
316 |
317 | .clear {
318 | clear: both;
319 | display: block;
320 | overflow: hidden;
321 | visibility: hidden;
322 | width: 0;
323 | height: 0;
324 | }
325 |
326 | /**
327 | * Non-semantic helper classes: please define your styles before this section.
328 | */
329 |
330 | /* For image replacement */
331 | .ir { display: block; text-indent: -999em; overflow: hidden; background-repeat: no-repeat; text-align: left; direction: ltr; }
332 |
333 | /* Hide for both screenreaders and browsers:
334 | css-discuss.incutio.com/wiki/Screenreader_Visibility */
335 | .hidden { display: none; visibility: hidden; }
336 |
337 | /* Hide only visually, but have it available for screenreaders: by Jon Neal.
338 | www.webaim.org/techniques/css/invisiblecontent/ & j.mp/visuallyhidden */
339 | .visuallyhidden { border: 0; clip: rect(0 0 0 0); height: 1px; margin: -1px; overflow: hidden; padding: 0; position: absolute; width: 1px; }
340 | /* Extends the .visuallyhidden class to allow the element to be focusable when navigated to via the keyboard: drupal.org/node/897638 */
341 | .visuallyhidden.focusable:active,
342 | .visuallyhidden.focusable:focus { clip: auto; height: auto; margin: 0; overflow: visible; position: static; width: auto; }
343 |
344 | /* Hide visually and from screenreaders, but maintain layout */
345 | .invisible { visibility: hidden; }
346 |
347 | /* The Magnificent Clearfix: Updated to prevent margin-collapsing on child elements.
348 | j.mp/bestclearfix */
349 | .clearfix:before, .clearfix:after { content: "\0020"; display: block; height: 0; overflow: hidden; }
350 | .clearfix:after { clear: both; }
351 | /* Fix clearfix: blueprintcss.lighthouseapp.com/projects/15318/tickets/5-extra-margin-padding-bottom-of-page */
352 | .clearfix { zoom: 1; }
353 |
354 |
355 |
356 | /**
357 | * Media queries for responsive design.
358 | *
359 | * These follow after primary styles so they will successfully override.
360 | */
361 |
362 | @media all and (orientation:portrait) {
363 | /* Style adjustments for portrait mode goes here */
364 |
365 | }
366 |
367 | @media all and (orientation:landscape) {
368 | /* Style adjustments for landscape mode goes here */
369 |
370 | }
371 |
372 | /* Grade-A Mobile Browsers (Opera Mobile, Mobile Safari, Android Chrome)
373 | consider this: www.cloudfour.com/css-media-query-for-mobile-is-fools-gold/ */
374 | @media screen and (max-device-width: 480px) {
375 |
376 |
377 | /* Uncomment if you don't want iOS and WinMobile to mobile-optimize the text for you: j.mp/textsizeadjust */
378 | /* html { -webkit-text-size-adjust:none; -ms-text-size-adjust:none; } */
379 | }
380 |
381 |
382 | /**
383 | * Print styles.
384 | *
385 | * Inlined to avoid required HTTP connection: www.phpied.com/delay-loading-your-print-css/
386 | */
387 | @media print {
388 | * { background: transparent !important; color: black !important; text-shadow: none !important; filter:none !important;
389 | -ms-filter: none !important; } /* Black prints faster: sanbeiji.com/archives/953 */
390 | a, a:visited { color: #444 !important; text-decoration: underline; }
391 | a[href]:after { content: " (" attr(href) ")"; }
392 | abbr[title]:after { content: " (" attr(title) ")"; }
393 | .ir a:after, a[href^="javascript:"]:after, a[href^="#"]:after { content: ""; } /* Don't show links for images, or javascript/internal links */
394 | pre, blockquote { border: 1px solid #999; page-break-inside: avoid; }
395 | thead { display: table-header-group; } /* css-discuss.incutio.com/wiki/Printing_Tables */
396 | tr, img { page-break-inside: avoid; }
397 | @page { margin: 0.5cm; }
398 | p, h2, h3 { orphans: 3; widows: 3; }
399 | h2, h3{ page-break-after: avoid; }
400 | }
401 |
402 |
--------------------------------------------------------------------------------
/dashboard/static/js/autocomplete.js:
--------------------------------------------------------------------------------
1 | (function(window, $) {
2 |
3 | window._results = {};
4 |
5 | var search = $('input[type="text"]'),
6 | geocoder = new google.maps.Geocoder();
7 |
8 | search.autocomplete({
9 | select: function(event, ui) {
10 | var url = '/search/?',
11 | value = ui.item.value,
12 | parameters = window._results[value];
13 | parameters['q'] = value;
14 | console.log(parameters);
15 | window.location = url + $.param(parameters);
16 | },
17 | source: function(request, response) {
18 | // Grab the source objects from Google Maps.
19 | var southwest = new google.maps.LatLng(37.68, -122.57),
20 | northeast = new google.maps.LatLng(37.84, -122.35),
21 | bounds = new google.maps.LatLngBounds(southwest, northeast);
22 |
23 | geocoder.geocode({
24 | 'address': request.term,
25 | 'bounds': bounds
26 | }, function(results, status){
27 | response($.map(results, function(item){
28 | var location = item.geometry.location,
29 | coordinates = {
30 | 'lat': location.lat(),
31 | 'lng': location.lng()
32 | };
33 | window._results[item.formatted_address] = coordinates;
34 | return {
35 | label: item.formatted_address,
36 | value: item.formatted_address,
37 | }
38 | }));
39 | });
40 | }
41 | });
42 | })(window, jQuery);
43 |
--------------------------------------------------------------------------------
/dashboard/static/js/charts/dual_state_barchart.js:
--------------------------------------------------------------------------------
1 | var paper;
2 | var barchart = {
3 | clear: function(){
4 | paper.clear();
5 | },
6 | render: function(fromDate,toDate,data) {
7 | function validateDate(d){
8 | return d.substring(0,2) + "/" + d.substring(2,4) + "/" + d.substring(4,8);
9 | };
10 |
11 | var totalData = [];
12 | for (i=0; i| {{ request.get_service_name }} | 38 |{{ request.requested_datetime }} | 39 |
No requests currently open.
44 | {% endif %} 45 |50 | {{ neighborhood.name }} 51 |
{% endif %} 52 | 53 |30-Day Trend
54 |{{ stats.average_response }} 55 | day{{ stats.average_response|pluralize }}
56 |Average Response Time
57 || {{ type.count }} | 65 |
| {{ nearby_place.name }}{{ nearby_place.street_name|title}} | 77 |
Your username and password didn't match. Please try again.
9 | {% endif %} 10 | 11 | 27 |15 |