def parcels_for_multi_request(req):
#
# [{ "lat": <lat>,
# "lng": <lng>,
# "id": <id> }]
try:
print(req.GET["points"])
points = json.loads(req.GET["points"])
except KeyError as kerr:
raise ErrorResponse("",
{"error": "Missing required key: {}".format(kerr)})
except ValueError:
raise ErrorResponse(
"", {
"error":
"Malformed 'points' value; must be valid JSON array: {}".
format(e)
})
query = None
for point in points:
q = Q(shape__contains=Point(point["lng"], point["lat"], srid=4326))
if query:
query |= q
else:
query = q
return Parcel.objects.filter(query)
def parcels_for_multi_request(req):
"""
Find parcels using the "points" parameter of a GET request. The value
should be a JSON-encoded array of dictionaries with "lat", "lng", and "id"
values. UNUSED.
"""
try:
print(req.GET["points"])
points = json.loads(req.GET["points"])
except KeyError as kerr:
raise ErrorResponse("",
{"error": "Missing required key: {}".format(kerr)})
except ValueError:
raise ErrorResponse(
"", {
"error":
"Malformed 'points' value; must be valid JSON array: {}".
format(e)
})
query = None
for point in points:
q = Q(shape__contains=Point(point["lng"], point["lat"], srid=4326))
if query:
query |= q
else:
query = qe
return Parcel.objects.filter(query)
def confirm(request):
try:
user = authenticate(pk=request.GET["uid"], token=request.GET["token"])
if not user:
raise ErrorResponse("Invalid user id or token")
if "sub" in request.GET:
subscription = user.subscriptions.get(pk=request.GET["sub"])
else:
subscription = user.subscriptions.all().order_by("-created")[0]
subscription.confirm()
return {
"title":
"Subscription confirmed",
"text": ("Now that we know you are who you say you are, "
"we'll send you updates about projects in the "
"area you selected."),
"tags":
"success"
}
except KeyError as kwerr:
raise ErrorResponse("Missing required param: " + kwerr.args[0])
except Subscription.DoesNotExist:
raise ErrorResponse("Invalid token or subscription id.")
except IndexError:
raise ErrorResponse("That user does not have a subscription")
def do_resend_email(request):
try:
email = request.POST["email"]
user = User.objects.get(email=email)
tasks.resend_user_key.delay(user.id)
except KeyError:
raise ErrorResponse("Bad request", status=405)
except User.DoesNotExist:
raise ErrorResponse(
"There is no registered user with that email address.",
redirect_back=True)
return {
"status": "OK",
"message": "We've sent a new login link to " + email
}
def list_proposals(req):
proposals = _query(req)
try:
page = int(req.GET["page"])
except (ValueError, KeyError):
page = 1
context = {}
if page:
try:
per_page = int(req.GET.get("per_page", 50))
except ValueError:
per_page = 50
paginator = Paginator(proposals, per_page=min(per_page, 50))
proposals = paginator.page(page)
try:
query_params = req.GET.copy()
def make_url(page):
query_params["page"] = page
return req.path + "?" + query_params.urlencode()
context["paginator"] = paginator_context(proposals, make_url)
except (PageNotAnInteger, EmptyPage) as err:
raise ErrorResponse("No such page", {"page": page}, err=err)
context["proposals"] = [
proposal_json(proposal, include_images=1, include_events=True)
for proposal in proposals
]
return context
def paginated_active_proposals(req):
proposal_query = Proposal.objects.filter(build_proposal_query(req.GET))
if "include_projects" in req.GET:
proposal_query = proposal_query.select_related("project")
paginator = Paginator(proposal_query, per_page=100)
page = req.GET.get("page")
try:
proposals = paginator.page(page)
except PageNotAnInteger:
proposals = paginator.page(1)
except EmptyPage as err:
raise ErrorResponse("No such page", {"page": page}, err=err)
pjson = [
proposal_json(
proposal, include_images=1) for proposal in proposals
]
return {
"proposals": pjson,
# "count": proposals.paginator.count,
"page": proposals.number,
"total_pages": proposals.paginator.num_pages
}
def find_parcels(req):
try:
parcel = parcels_for_request(req)[0]
include_attributes = req.GET.get("attributes", False)
except IndexError:
raise ErrorResponse("No matching parcels found", status=404)
return make_parcel_data(parcel, include_attributes=include_attributes)
def task_statuses(req):
try:
statuses = {
task_id: task_status_dict(task_id)
for task_id in req.GET["ids"].split(",")
}
return {"results": statuses}
except KeyError:
raise ErrorResponse("Missing parameter 'ids'", status=400)
def parcels_for_request(req):
"""
Helper function for retrieving the parcel(s) at a given latitude and
longitude.
"""
try:
lng = float(req.GET["lng"])
lat = float(req.GET["lat"])
except KeyError as kerr:
raise ErrorResponse(
"Bad parameters",
{"error": "Missing required key: {}".format(str(kerr))})
except ValueError:
raise ErrorResponse("Bad parameter",
{"error": "Bad value for latitude and longitude."})
return Parcel.objects.\
filter(shape__contains=Point(lng, lat, srid=4326)).\
transform()
def subscribe(request):
"""
Set up a new subscription.
"""
# Validate the request:
if request.method != "POST":
raise ErrorResponse("Request must use POST method.", status=405)
try:
query_dict = json.loads(request.POST["query"])
except KeyError:
raise ErrorResponse("Missing a 'query' field")
except ValueError:
raise ErrorResponse("Malformed JSON in 'query' field.")
if query_dict != {}:
query_dict = validate_query(query_dict)
if not query_dict:
raise ErrorResponse("Invalid filter options",
{"query": query_dict})
user = request.user
new_user = False
has_subscriptions = False
if user.is_anonymous():
try:
email = request.POST["email"]
user = User.objects.get(email=email)
has_subscriptions = user.subscriptions.filter(active=True).exists()
except KeyError as kerr:
raise ErrorResponse("Missing required key:" + kerr.args[0], {})
except User.DoesNotExist:
language = request.GET.get("language", "en-US")
lang, _reg = language.split("-", 1)
user = User.objects.create(
is_active=False,
username=email,
email=email,
)
profile = UserProfile.objects.create(user=user, language=lang)
profile.save()
new_user = True
try:
subscription = Subscription()
subscription.set_validated_query(query_dict)
subscription.user = user
subscription.save()
except Exception as exc:
raise ErrorResponse("Invalid subscription", {"exception": exc.args})
return {
"new_user": new_user,
"active": user.is_active,
"email": user.email,
"has_subscriptions": has_subscriptions
}
def change_log(request):
"""
Show a summary of changes based on criteria in the query string.
"""
params = request.GET.copy()
try:
since = datetime.strptime(params["since"], "%Y%m%d")
del params["since"]
except KeyError as kerr:
raise ErrorResponse("Missing required param: since")
except ValueError as err:
raise ErrorResponse("'since' should have the format YYYYmmdd")
until = request.GET.get("until")
if "sub_id" in request.GET:
sub = get_object_or_404(Subscription, pk=request.GET["sub_id"])
query = sub.query_dict
else:
query = Subscription.validate_query(params)
summary = changes.summarize_query_updates(query, since)
return {"since": since, "until": until, "changes": summary}
def make_query(d, reducer=operator.and_):
subqueries = []
if "id" in d:
return Q(pk=d["id"])
if "lng" in d and "lat" in d:
try:
lat = float(d["lat"])
lng = float(d["lng"])
subqueries.append(Q(shape__contains=Point(lng, lat, srid=4326)))
except ValueError as err:
raise ErrorResponse(
"Bad parameter",
{"error": "Bad value for latitude or longitude."},
err=err)
if "loc_id" in d:
subqueries.append(Q(loc_id=d["loc_id"]))
street = d.get("street")
number = d.get("number")
if not street and "address" in d:
m = split_address(d["address"])
if m:
number, street = m
if street:
sq = {"full_street": normalize_street(street)}
if number:
sq["address_num"] = normalize_number(number)
subqueries.append(Q(**sq))
if d.get("mode") == "or":
reducer = operator.or_
q = reduce(reducer, subqueries)
if "types" in d:
types = [t.upper() for t in re.split(r"\s*,\s*", d["types"])]
return q & Q(poly_type__in=types)
elif "include_row" not in d:
return q & ~Q(poly_type="ROW")
def show_change_summary(request, user, sub_id, since, until=None):
"""
Displays a summary of the changes recorded for a given subscription within
a time period specified by `since` and `until`.
"""
try:
sub = Subscription.objects.get(user=user, pk=sub_id)
summary = changes.summarize_subscription_updates(sub, since, until)
return {
"since": since,
"until": until,
"subscription": sub,
"changes": summary
}
except Subscription.DoesNotExist:
raise ErrorResponse("Invalid subscription ID",
status=404,
redirect_back=True)
def subscribe(request):
"""
Set up a new subscription. If the supplied
"""
if request.method != "POST":
raise ErrorResponse("Request must use POST method.", status=405)
try:
query_dict = json.loads(request.POST["query"])
except KeyError:
raise ErrorResponse("Missing a 'query' field")
except ValueError:
raise ErrorResponse("Malformed JSON in 'query' field.")
if query_dict != {}:
query_dict = validate_query(query_dict)
if not query_dict:
raise ErrorResponse("Invalid query", {"query": query_dict})
user = request.user
new_user = False
if user.is_anonymous():
try:
email = request.POST["email"]
user = User.objects.get(email=email)
except KeyError as kerr:
raise ErrorResponse("Missing required key:" + kerr.args[0], {})
except User.DoesNotExist:
user = User.objects.create(username=email, email=email)
profile = UserProfile.objects.create(user=user)
profile.save()
new_user = True
try:
subscription = Subscription()
subscription.set_validated_query(query_dict)
user.subscriptions.add(subscription)
except Exception as exc:
raise ErrorResponse("Invalid subscription", {"exception": exc.args})
return {
"new_user": new_user,
"active": user.is_active,
"email": user.email
}
def make_query(d):
subqueries = []
if "lng" in d and "lat" in d:
try:
lat = float(d["lat"])
lng = float(d["lng"])
subqueries.append(Q(shape__contains=Point(lng, lat, srid=4326)))
except ValueError as err:
raise ErrorResponse(
"Bad parameter",
{"error": "Bad value for latitude or longitude."},
err=err)
if "loc_id" in d:
subqueries.append(Q(loc_id=d["loc_id"]))
if "types" in d:
types = [t.upper() for t in re.split(r"\s*,\s*", d["types"])]
subqueries.append(Q(poly_type__in=types))
elif "include_row" not in d:
subqueries.append(~Q(poly_type="ROW"))
return reduce(lambda q1, q2: q1 & q2, subqueries)
def task_status(req):
try:
return task_status_dict(req.GET["id"])
except KeyError:
raise ErrorResponse("Missing parameter 'id'", status=400)
def parcel_at_point(req):
try:
parcel = parcels_for_request(req)[0]
except IndexError:
raise ErrorResponse("No matching parcels found", status=404)
return make_parcel_data(parcel)
