def view_audio_file(request, pk, _):
"""Using the ID, return the oral argument page.
We also test if the item is a favorite and send data as such.
"""
af = get_object_or_404(Audio, pk=pk)
title = trunc(af.case_name, 100)
get_string = search_utils.make_get_string(request)
try:
fave = Favorite.objects.get(audio_id=af.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(initial={
'audio_id': af.pk,
'name': trunc(best_case_name(af.docket), 100, ellipsis='...'),
})
else:
favorite_form = FavoriteForm(instance=fave)
return render(request, 'oral_argument.html', {
'title': title,
'af': af,
'favorite_form': favorite_form,
'get_string': get_string,
'private': af.blocked,
})
def view_audio_file(request, pk, _):
"""Using the ID, return the oral argument page.
We also test if the item is a favorite and send data as such.
"""
af = get_object_or_404(Audio, pk=pk)
title = trunc(af.case_name, 100)
get_string = search_utils.make_get_string(request)
try:
fave = Favorite.objects.get(audio_id=af.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(
initial={
'audio_id': af.pk,
'name': trunc(best_case_name(af.docket), 100, ellipsis='...'),
})
else:
favorite_form = FavoriteForm(instance=fave)
return render(
request, 'oral_argument.html', {
'title': title,
'af': af,
'favorite_form': favorite_form,
'get_string': get_string,
'private': af.blocked,
})
def view_docket(request, pk, slug):
docket = get_object_or_404(Docket, pk=pk)
if not is_bot(request):
with suppress_autotime(docket, ['date_modified']):
cached_count = docket.view_count
docket.view_count = F('view_count') + 1
docket.save()
docket.view_count = cached_count + 1
try:
fave = Favorite.objects.get(docket_id=docket.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(
initial={
'docket_id': docket.pk,
'name': trunc(best_case_name(docket), 100, ellipsis='...'),
})
else:
favorite_form = FavoriteForm(instance=fave)
de_list = docket.docket_entries.all().prefetch_related('recap_documents')
form = DocketEntryFilterForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
if cd.get('entry_gte'):
de_list = de_list.filter(entry_number__gte=cd['entry_gte'])
if cd.get('entry_lte'):
de_list = de_list.filter(entry_number__lte=cd['entry_lte'])
if cd.get('filed_after'):
de_list = de_list.filter(date_filed__gte=cd['filed_after'])
if cd.get('filed_before'):
de_list = de_list.filter(date_filed__lte=cd['filed_before'])
if cd.get('order_by') == DocketEntryFilterForm.DESCENDING:
de_list = de_list.order_by('-entry_number')
paginator = Paginator(de_list, 100, orphans=5)
page = request.GET.get('page')
try:
docket_entries = paginator.page(page)
except PageNotAnInteger:
docket_entries = paginator.page(1)
except EmptyPage:
docket_entries = paginator.page(paginator.num_pages)
return render(
request,
'view_docket.html',
{
'docket': docket,
'parties':
docket.parties.exists(), # Needed to show/hide parties tab.
'docket_entries': docket_entries,
'form': form,
'favorite_form': favorite_form,
'get_string': make_get_string(request),
'timezone': COURT_TIMEZONES.get(docket.court_id, 'US/Eastern'),
'private': docket.blocked,
})
def view_opinion(request, pk, _):
"""Using the cluster ID, return the cluster of opinions.
We also test if the cluster ID is a favorite for the user, and send data
if needed. If it's a favorite, we send the bound form for the favorite so
it can populate the form on the page. If it is not a favorite, we send the
unbound form.
"""
# Look up the court, cluster, title and favorite information
cluster = get_object_or_404(OpinionCluster, pk=pk)
title = '%s, %s' % (
trunc(best_case_name(cluster), 100),
cluster.citation_string,
)
get_string = search_utils.make_get_string(request)
try:
fave = Favorite.objects.get(
cluster_id=cluster.pk,
user=request.user,
)
favorite_form = FavoriteForm(instance=fave)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(
initial={
'cluster_id': cluster.pk,
'name': trunc(best_case_name(cluster), 100, ellipsis='...'),
}
)
# Get the citing results from Solr for speed.
conn = sunburnt.SolrInterface(settings.SOLR_OPINION_URL, mode='r')
q = {
'q': 'cites:({ids})'.format(
ids=' OR '.join([str(pk) for pk in
(cluster.sub_opinions
.values_list('pk', flat=True))])
),
'rows': 5,
'start': 0,
'sort': 'citeCount desc',
'caller': 'view_opinion',
}
citing_clusters = conn.raw_query(**q).execute()
return render_to_response(
'view_opinion.html',
{
'title': title,
'cluster': cluster,
'favorite_form': favorite_form,
'get_string': get_string,
'private': cluster.blocked,
'citing_clusters': citing_clusters,
'top_authorities': cluster.authorities[:5],
},
RequestContext(request)
)
def view_opinion(request, pk, _):
"""Using the cluster ID, return the cluster of opinions.
We also test if the cluster ID is a favorite for the user, and send data
if needed. If it's a favorite, we send the bound form for the favorite so
it can populate the form on the page. If it is not a favorite, we send the
unbound form.
"""
# Look up the court, cluster, title and favorite information
cluster = get_object_or_404(OpinionCluster, pk=pk)
title = ", ".join([
s for s in [
trunc(best_case_name(cluster), 100, ellipsis="..."),
cluster.citation_string,
] if s.strip()
])
has_downloads = False
for sub_opinion in cluster.sub_opinions.all():
if sub_opinion.local_path or sub_opinion.download_url:
has_downloads = True
break
get_string = make_get_string(request)
try:
fave = Favorite.objects.get(cluster_id=cluster.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(
initial={
"cluster_id": cluster.pk,
"name": trunc(best_case_name(cluster), 100, ellipsis="..."),
})
else:
favorite_form = FavoriteForm(instance=fave)
citing_clusters = get_citing_clusters_with_cache(cluster, is_bot(request))
return render(
request,
"view_opinion.html",
{
"title": title,
"cluster": cluster,
"has_downloads": has_downloads,
"favorite_form": favorite_form,
"get_string": get_string,
"private": cluster.blocked,
"citing_clusters": citing_clusters,
"top_authorities": cluster.authorities_with_data[:5],
"authorities_count": len(cluster.authorities_with_data),
},
)
def view_docket(request, pk, _):
docket = get_object_or_404(Docket, pk=pk)
if not is_bot(request):
docket.view_count = F('view_count') + 1
docket.save()
try:
fave = Favorite.objects.get(docket_id=docket.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(
initial={
'docket_id': docket.pk,
'name': trunc(best_case_name(docket), 100, ellipsis='...'),
})
else:
favorite_form = FavoriteForm(instance=fave)
de_list = docket.docket_entries.all()
form = DocketEntryFilterForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
if cd.get('entry_gte'):
de_list = de_list.filter(entry_number__gte=cd['entry_gte'])
if cd.get('entry_lte'):
de_list = de_list.filter(entry_number__lte=cd['entry_lte'])
if cd.get('filed_after'):
de_list = de_list.filter(date_filed__gte=cd['filed_after'])
if cd.get('filed_before'):
de_list = de_list.filter(date_filed__lte=cd['filed_before'])
if cd.get('order_by') == DocketEntryFilterForm.DESCENDING:
de_list = de_list.order_by('-entry_number')
paginator = Paginator(de_list, 500, orphans=25)
page = request.GET.get('page')
try:
docket_entries = paginator.page(page)
except PageNotAnInteger:
docket_entries = paginator.page(1)
except EmptyPage:
docket_entries = paginator.page(paginator.num_pages)
return render(
request, 'view_docket.html', {
'docket': docket,
'docket_entries': docket_entries,
'form': form,
'favorite_form': favorite_form,
'get_string': make_get_string(request),
'private': docket.blocked,
})
def view_docket(request, pk, _):
docket = get_object_or_404(Docket, pk=pk)
if not is_bot(request):
docket.view_count = F('view_count') + 1
docket.save()
try:
fave = Favorite.objects.get(docket_id=docket.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(initial={
'docket_id': docket.pk,
'name': trunc(best_case_name(docket), 100, ellipsis='...'),
})
else:
favorite_form = FavoriteForm(instance=fave)
de_list = docket.docket_entries.all()
form = DocketEntryFilterForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
if cd.get('entry_gte'):
de_list = de_list.filter(entry_number__gte=cd['entry_gte'])
if cd.get('entry_lte'):
de_list = de_list.filter(entry_number__lte=cd['entry_lte'])
if cd.get('filed_after'):
de_list = de_list.filter(date_filed__gte=cd['filed_after'])
if cd.get('filed_before'):
de_list = de_list.filter(date_filed__lte=cd['filed_before'])
if cd.get('order_by') == DocketEntryFilterForm.DESCENDING:
de_list = de_list.order_by('-entry_number')
paginator = Paginator(de_list, 500, orphans=25)
page = request.GET.get('page')
try:
docket_entries = paginator.page(page)
except PageNotAnInteger:
docket_entries = paginator.page(1)
except EmptyPage:
docket_entries = paginator.page(paginator.num_pages)
return render(request, 'view_docket.html', {
'docket': docket,
'docket_entries': docket_entries,
'form': form,
'favorite_form': favorite_form,
'get_string': make_get_string(request),
'private': docket.blocked,
})
def view_docket(request, pk, slug):
docket, context = core_docket_data(request, pk)
if not is_bot(request):
with suppress_autotime(docket, ['date_modified']):
cached_count = docket.view_count
docket.view_count = F('view_count') + 1
docket.save()
docket.view_count = cached_count + 1
de_list = docket.docket_entries.all().prefetch_related('recap_documents')
form = DocketEntryFilterForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
if cd.get('entry_gte'):
de_list = de_list.filter(entry_number__gte=cd['entry_gte'])
if cd.get('entry_lte'):
de_list = de_list.filter(entry_number__lte=cd['entry_lte'])
if cd.get('filed_after'):
de_list = de_list.filter(date_filed__gte=cd['filed_after'])
if cd.get('filed_before'):
de_list = de_list.filter(date_filed__lte=cd['filed_before'])
if cd.get('order_by') == DocketEntryFilterForm.DESCENDING:
de_list = de_list.order_by('-recap_sequence_number',
'-entry_number')
paginator = Paginator(de_list, 200, orphans=10)
page = request.GET.get('page')
try:
docket_entries = paginator.page(page)
except PageNotAnInteger:
docket_entries = paginator.page(1)
except EmptyPage:
docket_entries = paginator.page(paginator.num_pages)
context.update({
'parties': docket.parties.exists(), # Needed to show/hide parties tab.
'docket_entries': docket_entries,
'form': form,
'get_string': search_utils.make_get_string(request),
})
return render(request, 'view_docket.html', context)
def view_docket(request, pk, slug):
docket, context = core_docket_data(request, pk)
if not is_bot(request):
with suppress_autotime(docket, ['date_modified']):
cached_count = docket.view_count
docket.view_count = F('view_count') + 1
docket.save()
docket.view_count = cached_count + 1
de_list = docket.docket_entries.all().prefetch_related('recap_documents')
form = DocketEntryFilterForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
if cd.get('entry_gte'):
de_list = de_list.filter(entry_number__gte=cd['entry_gte'])
if cd.get('entry_lte'):
de_list = de_list.filter(entry_number__lte=cd['entry_lte'])
if cd.get('filed_after'):
de_list = de_list.filter(date_filed__gte=cd['filed_after'])
if cd.get('filed_before'):
de_list = de_list.filter(date_filed__lte=cd['filed_before'])
if cd.get('order_by') == DocketEntryFilterForm.DESCENDING:
de_list = de_list.order_by('-recap_sequence_number',
'-entry_number')
paginator = Paginator(de_list, 200, orphans=10)
page = request.GET.get('page')
try:
docket_entries = paginator.page(page)
except PageNotAnInteger:
docket_entries = paginator.page(1)
except EmptyPage:
docket_entries = paginator.page(paginator.num_pages)
context.update({
'parties': docket.parties.exists(), # Needed to show/hide parties tab.
'docket_entries': docket_entries,
'form': form,
'get_string': search_utils.make_get_string(request),
})
return render(request, 'view_docket.html', context)
def view_docket(request, pk, slug):
docket, context = core_docket_data(request, pk)
if not is_bot(request):
with suppress_autotime(docket, ["date_modified"]):
cached_count = docket.view_count
docket.view_count = F("view_count") + 1
docket.save()
docket.view_count = cached_count + 1
de_list = docket.docket_entries.all().prefetch_related("recap_documents")
form = DocketEntryFilterForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
if cd.get("entry_gte"):
de_list = de_list.filter(entry_number__gte=cd["entry_gte"])
if cd.get("entry_lte"):
de_list = de_list.filter(entry_number__lte=cd["entry_lte"])
if cd.get("filed_after"):
de_list = de_list.filter(date_filed__gte=cd["filed_after"])
if cd.get("filed_before"):
de_list = de_list.filter(date_filed__lte=cd["filed_before"])
if cd.get("order_by") == DocketEntryFilterForm.DESCENDING:
de_list = de_list.order_by("-recap_sequence_number",
"-entry_number")
paginator = Paginator(de_list, 200, orphans=10)
page = request.GET.get("page")
try:
docket_entries = paginator.page(page)
except PageNotAnInteger:
docket_entries = paginator.page(1)
except EmptyPage:
docket_entries = paginator.page(paginator.num_pages)
context.update({
"parties": docket.parties.exists(), # Needed to show/hide parties tab.
"docket_entries": docket_entries,
"form": form,
"get_string": make_get_string(request),
})
return render(request, "view_docket.html", context)
def view_docket(request: HttpRequest, pk: int, slug: str) -> HttpResponse:
docket, context = core_docket_data(request, pk)
increment_view_count(docket, request)
de_list = docket.docket_entries.all().prefetch_related("recap_documents")
form = DocketEntryFilterForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
if cd.get("entry_gte"):
de_list = de_list.filter(entry_number__gte=cd["entry_gte"])
if cd.get("entry_lte"):
de_list = de_list.filter(entry_number__lte=cd["entry_lte"])
if cd.get("filed_after"):
de_list = de_list.filter(date_filed__gte=cd["filed_after"])
if cd.get("filed_before"):
de_list = de_list.filter(date_filed__lte=cd["filed_before"])
if cd.get("order_by") == DocketEntryFilterForm.DESCENDING:
de_list = de_list.order_by(
"-recap_sequence_number", "-entry_number"
)
paginator = Paginator(de_list, 200, orphans=10)
page = request.GET.get("page", 1)
try:
docket_entries = paginator.page(page)
except PageNotAnInteger:
docket_entries = paginator.page(1)
except EmptyPage:
docket_entries = paginator.page(paginator.num_pages)
context.update(
{
"parties": docket.parties.exists(), # Needed to show/hide parties tab.
"docket_entries": docket_entries,
"form": form,
"get_string": make_get_string(request),
}
)
return render(request, "view_docket.html", context)
def view_opinion(request, pk, _):
"""Using the cluster ID, return the cluster of opinions.
We also test if the cluster ID is a favorite for the user, and send data
if needed. If it's a favorite, we send the bound form for the favorite so
it can populate the form on the page. If it is not a favorite, we send the
unbound form.
"""
# Look up the court, cluster, title and favorite information
cluster = get_object_or_404(OpinionCluster, pk=pk)
title = ', '.join([s for s in [
trunc(best_case_name(cluster), 100, ellipsis="..."),
cluster.citation_string,
] if s.strip()])
has_downloads = False
for sub_opinion in cluster.sub_opinions.all():
if sub_opinion.local_path or sub_opinion.download_url:
has_downloads = True
break
get_string = search_utils.make_get_string(request)
try:
fave = Favorite.objects.get(cluster_id=cluster.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(initial={
'cluster_id': cluster.pk,
'name': trunc(best_case_name(cluster), 100, ellipsis='...'),
})
else:
favorite_form = FavoriteForm(instance=fave)
if not is_bot(request):
# Get the citing results from Solr for speed. Only do this for humans
# to save on disk usage.
conn = sunburnt.SolrInterface(settings.SOLR_OPINION_URL, mode='r')
q = {
'q': 'cites:({ids})'.format(
ids=' OR '.join([str(pk) for pk in
(cluster.sub_opinions
.values_list('pk', flat=True))])
),
'rows': 5,
'start': 0,
'sort': 'citeCount desc',
'caller': 'view_opinion',
}
citing_clusters = conn.raw_query(**q).execute()
else:
citing_clusters = None
return render(request, 'view_opinion.html', {
'title': title,
'cluster': cluster,
'has_downloads': has_downloads,
'favorite_form': favorite_form,
'get_string': get_string,
'private': cluster.blocked,
'citing_clusters': citing_clusters,
'top_authorities': cluster.authorities[:5],
})
def show_results(request):
"""
This view can vary significantly, depending on how it is called:
- In its most simple form, it is called via GET and without any
parameters.
--> This loads the homepage.
- It might also be called with GET *with* parameters.
--> This loads search results.
- It might be called with a POST.
--> This attempts to save an alert.
It also has a few failure modes it needs to support:
- It must react properly to an invalid alert form.
- It must react properly to an invalid or failing search form.
All of these paths have tests.
"""
# Create a search string that does not contain the page numbers
get_string = search_utils.make_get_string(request)
get_string_sans_alert = search_utils.make_get_string(request, ['page', 'edit_alert'])
render_dict = {
'private': True,
'get_string': get_string,
'get_string_sans_alert': get_string_sans_alert,
}
if request.method == 'POST':
# The user is trying to save an alert.
alert_form = CreateAlertForm(request.POST, user=request.user)
if alert_form.is_valid():
cd = alert_form.cleaned_data
# save the alert
if request.POST.get('edit_alert'):
# check if the user can edit this, or if they are url hacking
alert = get_object_or_404(
Alert,
pk=request.POST.get('edit_alert'),
user=request.user,
)
alert_form = CreateAlertForm(cd, instance=alert,
user=request.user)
alert_form.save()
action = "edited"
else:
alert_form = CreateAlertForm(cd, user=request.user)
alert = alert_form.save(commit=False)
alert.user = request.user
alert.save()
action = "created"
messages.add_message(request, messages.SUCCESS,
'Your alert was %s successfully.' % action)
# and redirect to the alerts page
return HttpResponseRedirect(reverse("profile_alerts"))
else:
# Invalid form. Do the search again and show them the alert form
# with the errors
render_dict.update(do_search(request))
render_dict.update({'alert_form': alert_form})
return render_to_response(
'search.html',
render_dict,
RequestContext(request),
)
else:
# Either a search or the homepage
if len(request.GET) == 0:
# No parameters --> Homepage.
if not is_bot(request):
tally_stat('search.homepage_loaded')
# Load the render_dict with good results that can be shown in the
# "Latest Cases" section
render_dict.update(do_search(request, rows=5,
order_by='dateFiled desc'))
# Get the results from the oral arguments as well
oa_dict = do_search(request, rows=5, order_by='dateArgued desc',
type='oa')
render_dict.update({'results_oa': oa_dict['results']})
# But give it a fresh form for the advanced search section
render_dict.update({'search_form': SearchForm(request.GET)})
ten_days_ago = make_aware(datetime.today() - timedelta(days=10), utc)
alerts_in_last_ten = Stat.objects.filter(
name__contains='alerts.sent',
date_logged__gte=ten_days_ago
).aggregate(Sum('count'))['count__sum']
queries_in_last_ten = Stat.objects.filter(
name='search.results',
date_logged__gte=ten_days_ago
).aggregate(Sum('count'))['count__sum']
bulk_in_last_ten = Stat.objects.filter(
name__contains='bulk_data',
date_logged__gte=ten_days_ago
).aggregate(Sum('count'))['count__sum']
r = redis.StrictRedis(
host=settings.REDIS_HOST,
port=settings.REDIS_PORT,
db=settings.REDIS_DATABASES['STATS'],
)
last_ten_days = ['api:v3.d:%s.count' %
(date.today() - timedelta(days=x)).isoformat()
for x in range(0, 10)]
api_in_last_ten = sum(
[int(result) for result in
r.mget(*last_ten_days) if result is not None]
)
users_in_last_ten = User.objects.filter(
date_joined__gte=ten_days_ago
).count()
opinions_in_last_ten = Opinion.objects.filter(
date_created__gte=ten_days_ago
).count()
oral_arguments_in_last_ten = Audio.objects.filter(
date_created__gte=ten_days_ago
).count()
days_of_oa = naturalduration(
Audio.objects.aggregate(
Sum('duration')
)['duration__sum'],
as_dict=True,
)['d']
viz_in_last_ten = SCOTUSMap.objects.filter(
date_published__gte=ten_days_ago,
published=True,
).count()
visualizations = SCOTUSMap.objects.filter(
published=True,
deleted=False,
).annotate(
Count('clusters'),
).filter(
# Ensures that we only show good stuff on homepage
clusters__count__gt=10,
).order_by(
'-date_published',
'-date_modified',
'-date_created',
)[:1]
render_dict.update({
'alerts_in_last_ten': alerts_in_last_ten,
'queries_in_last_ten': queries_in_last_ten,
'opinions_in_last_ten': opinions_in_last_ten,
'oral_arguments_in_last_ten': oral_arguments_in_last_ten,
'bulk_in_last_ten': bulk_in_last_ten,
'api_in_last_ten': api_in_last_ten,
'users_in_last_ten': users_in_last_ten,
'days_of_oa': days_of_oa,
'viz_in_last_ten': viz_in_last_ten,
'visualizations': visualizations,
'private': False, # VERY IMPORTANT!
})
return render_to_response(
'homepage.html',
render_dict,
RequestContext(request)
)
else:
# User placed a search or is trying to edit an alert
if request.GET.get('edit_alert'):
# They're editing an alert
if request.user.is_anonymous():
return HttpResponseRedirect(
"{path}?next={next}{encoded_params}".format(
path=reverse('sign-in'),
next=request.path,
encoded_params=quote("?" + request.GET.urlencode())
))
else:
alert = get_object_or_404(
Alert,
pk=request.GET.get('edit_alert'),
user=request.user
)
alert_form = CreateAlertForm(
instance=alert,
initial={'query': get_string_sans_alert},
user=request.user,
)
else:
# Just a regular search
if not is_bot(request):
tally_stat('search.results')
# Create bare-bones alert form.
alert_form = CreateAlertForm(
initial={'query': get_string,
'rate': "dly"},
user=request.user
)
render_dict.update(do_search(request))
render_dict.update({'alert_form': alert_form})
return render_to_response(
'search.html',
render_dict,
RequestContext(request),
)
def view_opinion(request, pk, _):
"""Using the cluster ID, return the cluster of opinions.
We also test if the cluster ID is a favorite for the user, and send data
if needed. If it's a favorite, we send the bound form for the favorite so
it can populate the form on the page. If it is not a favorite, we send the
unbound form.
"""
# Look up the court, cluster, title and favorite information
cluster = get_object_or_404(OpinionCluster, pk=pk)
title = ", ".join([
s for s in [
trunc(best_case_name(cluster), 100, ellipsis="..."),
cluster.citation_string,
] if s.strip()
])
has_downloads = False
for sub_opinion in cluster.sub_opinions.all():
if sub_opinion.local_path or sub_opinion.download_url:
has_downloads = True
break
get_string = search_utils.make_get_string(request)
try:
fave = Favorite.objects.get(cluster_id=cluster.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(
initial={
"cluster_id": cluster.pk,
"name": trunc(best_case_name(cluster), 100, ellipsis="..."),
})
else:
favorite_form = FavoriteForm(instance=fave)
if not is_bot(request):
# Get the citing results from Solr for speed. Only do this for humans
# to save on disk usage.
conn = sunburnt.SolrInterface(settings.SOLR_OPINION_URL, mode="r")
q = {
"q":
"cites:({ids})".format(ids=" OR ".join([
str(pk)
for pk in (cluster.sub_opinions.values_list("pk", flat=True))
])),
"rows":
5,
"start":
0,
"sort":
"citeCount desc",
"caller":
"view_opinion",
}
citing_clusters = conn.raw_query(**q).execute()
else:
citing_clusters = None
return render(
request,
"view_opinion.html",
{
"title": title,
"cluster": cluster,
"has_downloads": has_downloads,
"favorite_form": favorite_form,
"get_string": get_string,
"private": cluster.blocked,
"citing_clusters": citing_clusters,
"top_authorities": cluster.authorities_with_data[:5],
"authorities_count": len(cluster.authorities_with_data),
},
)
def show_results(request):
"""
This view can vary significantly, depending on how it is called:
- In its most simple form, it is called via GET and without any
parameters.
--> This loads the homepage.
- It might also be called with GET *with* parameters.
--> This loads search results.
- It might be called with a POST.
--> This attempts to save an alert.
It also has a few failure modes it needs to support:
- It must react properly to an invalid alert form.
- It must react properly to an invalid or failing search form.
All of these paths have tests.
"""
# Create a search string that does not contain the page numbers
get_string = make_get_string(request)
get_string_sans_alert = make_get_string(
request, ["page", "edit_alert", "show_alert_modal"])
render_dict = {
"private": True,
"get_string": get_string,
"get_string_sans_alert": get_string_sans_alert,
}
if request.method == "POST":
# The user is trying to save an alert.
alert_form = CreateAlertForm(request.POST, user=request.user)
if alert_form.is_valid():
cd = alert_form.cleaned_data
# save the alert
if request.POST.get("edit_alert"):
# check if the user can edit this, or if they are url hacking
alert = get_object_or_404(
Alert,
pk=request.POST.get("edit_alert"),
user=request.user,
)
alert_form = CreateAlertForm(cd,
instance=alert,
user=request.user)
alert_form.save()
action = "edited"
else:
alert_form = CreateAlertForm(cd, user=request.user)
alert = alert_form.save(commit=False)
alert.user = request.user
alert.save()
action = "created"
messages.add_message(
request,
messages.SUCCESS,
"Your alert was %s successfully." % action,
)
# and redirect to the alerts page
return HttpResponseRedirect(reverse("profile_alerts"))
else:
# Invalid form. Do the search again and show them the alert form
# with the errors
render_dict.update(do_search(request.GET.copy()))
render_dict.update({"alert_form": alert_form})
return render(request, "search.html", render_dict)
else:
# Either a search or the homepage
if len(request.GET) == 0:
# No parameters --> Homepage.
if not is_bot(request):
tally_stat("search.homepage_loaded")
# Ensure we get nothing from the future.
mutable_GET = request.GET.copy() # Makes it mutable
mutable_GET["filed_before"] = date.today()
# Load the render_dict with good results that can be shown in the
# "Latest Cases" section
render_dict.update(
do_search(
mutable_GET,
rows=5,
override_params={"order_by": "dateFiled desc"},
facet=False,
cache_key="homepage-data-o",
))
# Get the results from the oral arguments as well
render_dict.update({
"results_oa":
do_search(
mutable_GET,
rows=5,
override_params={
"order_by": "dateArgued desc",
"type": SEARCH_TYPES.ORAL_ARGUMENT,
},
facet=False,
cache_key="homepage-data-oa",
)["results"]
})
# But give it a fresh form for the advanced search section
render_dict.update({"search_form": SearchForm(request.GET)})
# Get a bunch of stats.
stats = get_homepage_stats()
render_dict.update(stats)
return render(request, "homepage.html", render_dict)
else:
# User placed a search or is trying to edit an alert
if request.GET.get("edit_alert"):
# They're editing an alert
if request.user.is_anonymous:
return HttpResponseRedirect(
"{path}?next={next}{encoded_params}".format(
path=reverse("sign-in"),
next=request.path,
encoded_params=quote("?" +
request.GET.urlencode()),
))
else:
alert = get_object_or_404(
Alert,
pk=request.GET.get("edit_alert"),
user=request.user,
)
alert_form = CreateAlertForm(
instance=alert,
initial={"query": get_string_sans_alert},
user=request.user,
)
else:
# Just a regular search
if not is_bot(request):
tally_stat("search.results")
# Create bare-bones alert form.
alert_form = CreateAlertForm(
initial={
"query": get_string,
"rate": "dly"
},
user=request.user,
)
render_dict.update(do_search(request.GET.copy()))
# Set the value to the query as a convenience
alert_form.fields["name"].widget.attrs["value"] = render_dict[
"search_summary_str"]
render_dict.update({"alert_form": alert_form})
return render(request, "search.html", render_dict)
def show_results(request):
"""
This view can vary significantly, depending on how it is called:
- In its most simple form, it is called via GET and without any
parameters.
--> This loads the homepage.
- It might also be called with GET *with* parameters.
--> This loads search results.
- It might be called with a POST.
--> This attempts to save an alert.
It also has a few failure modes it needs to support:
- It must react properly to an invalid alert form.
- It must react properly to an invalid or failing search form.
All of these paths have tests.
"""
# Create a search string that does not contain the page numbers
get_string = make_get_string(request)
get_string_sans_alert = make_get_string(request, ['page', 'edit_alert'])
render_dict = {
'private': True,
'get_string': get_string,
'get_string_sans_alert': get_string_sans_alert,
}
if request.method == 'POST':
# The user is trying to save an alert.
alert_form = CreateAlertForm(request.POST, user=request.user)
if alert_form.is_valid():
cd = alert_form.cleaned_data
# save the alert
if request.POST.get('edit_alert'):
# check if the user can edit this, or if they are url hacking
alert = get_object_or_404(
Alert,
pk=request.POST.get('edit_alert'),
user=request.user,
)
alert_form = CreateAlertForm(cd, instance=alert,
user=request.user)
alert_form.save()
action = "edited"
else:
alert_form = CreateAlertForm(cd, user=request.user)
alert = alert_form.save(commit=False)
alert.user = request.user
alert.save()
action = "created"
messages.add_message(request, messages.SUCCESS,
'Your alert was %s successfully.' % action)
# and redirect to the alerts page
return HttpResponseRedirect(reverse("profile_alerts"))
else:
# Invalid form. Do the search again and show them the alert form
# with the errors
render_dict.update(do_search(request))
render_dict.update({'alert_form': alert_form})
return render(request, 'search.html', render_dict)
else:
# Either a search or the homepage
if len(request.GET) == 0:
# No parameters --> Homepage.
if not is_bot(request):
tally_stat('search.homepage_loaded')
# Ensure we get nothing from the future.
request.GET = request.GET.copy() # Makes it mutable
request.GET['filed_before'] = date.today()
# Load the render_dict with good results that can be shown in the
# "Latest Cases" section
render_dict.update(do_search(request, rows=5,
order_by='dateFiled desc',
facet=False))
# Get the results from the oral arguments as well
oa_dict = do_search(request, rows=5, order_by='dateArgued desc',
type='oa', facet=False)
render_dict.update({'results_oa': oa_dict['results']})
# But give it a fresh form for the advanced search section
render_dict.update({'search_form': SearchForm(request.GET)})
# Get a bunch of stats.
render_dict.update(get_homepage_stats())
return render(request, 'homepage.html', render_dict)
else:
# User placed a search or is trying to edit an alert
if request.GET.get('edit_alert'):
# They're editing an alert
if request.user.is_anonymous():
return HttpResponseRedirect(
"{path}?next={next}{encoded_params}".format(
path=reverse('sign-in'),
next=request.path,
encoded_params=quote("?" + request.GET.urlencode())
))
else:
alert = get_object_or_404(
Alert,
pk=request.GET.get('edit_alert'),
user=request.user
)
alert_form = CreateAlertForm(
instance=alert,
initial={'query': get_string_sans_alert},
user=request.user,
)
else:
# Just a regular search
if not is_bot(request):
tally_stat('search.results')
# Create bare-bones alert form.
alert_form = CreateAlertForm(
initial={'query': get_string,
'rate': "dly"},
user=request.user
)
render_dict.update(do_search(request))
render_dict.update({'alert_form': alert_form})
return render(request, 'search.html', render_dict)
def show_results(request):
"""
This view can vary significantly, depending on how it is called:
- In its most simple form, it is called via GET and without any
parameters.
--> This loads the homepage.
- It might also be called with GET *with* parameters.
--> This loads search results.
- It might be called with a POST.
--> This attempts to save an alert.
It also has a few failure modes it needs to support:
- It must react properly to an invalid alert form.
- It must react properly to an invalid or failing search form.
All of these paths have tests.
"""
# Create a search string that does not contain the page numbers
get_string = search_utils.make_get_string(request)
get_string_sans_alert = search_utils.make_get_string(
request, ['page', 'edit_alert'])
render_dict = {
'private': True,
'get_string': get_string,
'get_string_sans_alert': get_string_sans_alert,
}
if request.method == 'POST':
# The user is trying to save an alert.
alert_form = CreateAlertForm(request.POST, user=request.user)
if alert_form.is_valid():
cd = alert_form.cleaned_data
# save the alert
if request.POST.get('edit_alert'):
# check if the user can edit this, or if they are url hacking
alert = get_object_or_404(
Alert,
pk=request.POST.get('edit_alert'),
user=request.user,
)
alert_form = CreateAlertForm(cd,
instance=alert,
user=request.user)
alert_form.save()
action = "edited"
else:
alert_form = CreateAlertForm(cd, user=request.user)
alert = alert_form.save(commit=False)
alert.user = request.user
alert.save()
action = "created"
messages.add_message(request, messages.SUCCESS,
'Your alert was %s successfully.' % action)
# and redirect to the alerts page
return HttpResponseRedirect(reverse("profile_alerts"))
else:
# Invalid form. Do the search again and show them the alert form
# with the errors
render_dict.update(do_search(request))
render_dict.update({'alert_form': alert_form})
return render_to_response(
'search.html',
render_dict,
RequestContext(request),
)
else:
# Either a search or the homepage
if len(request.GET) == 0:
# No parameters --> Homepage.
if not is_bot(request):
tally_stat('search.homepage_loaded')
# Load the render_dict with good results that can be shown in the
# "Latest Cases" section
render_dict.update(
do_search(request, rows=5, order_by='dateFiled desc'))
# Get the results from the oral arguments as well
oa_dict = do_search(request,
rows=5,
order_by='dateArgued desc',
type='oa')
render_dict.update({'results_oa': oa_dict['results']})
# But give it a fresh form for the advanced search section
render_dict.update({'search_form': SearchForm(request.GET)})
ten_days_ago = make_aware(datetime.today() - timedelta(days=10),
utc)
alerts_in_last_ten = Stat.objects.filter(
name__contains='alerts.sent',
date_logged__gte=ten_days_ago).aggregate(
Sum('count'))['count__sum']
queries_in_last_ten = Stat.objects.filter(
name='search.results',
date_logged__gte=ten_days_ago).aggregate(
Sum('count'))['count__sum']
bulk_in_last_ten = Stat.objects.filter(
name__contains='bulk_data',
date_logged__gte=ten_days_ago).aggregate(
Sum('count'))['count__sum']
r = redis.StrictRedis(
host=settings.REDIS_HOST,
port=settings.REDIS_PORT,
db=settings.REDIS_DATABASES['STATS'],
)
last_ten_days = [
'api:v3.d:%s.count' %
(date.today() - timedelta(days=x)).isoformat()
for x in range(0, 10)
]
api_in_last_ten = sum([
int(result) for result in r.mget(*last_ten_days)
if result is not None
])
users_in_last_ten = User.objects.filter(
date_joined__gte=ten_days_ago).count()
opinions_in_last_ten = Opinion.objects.filter(
date_created__gte=ten_days_ago).count()
oral_arguments_in_last_ten = Audio.objects.filter(
date_created__gte=ten_days_ago).count()
days_of_oa = naturalduration(
Audio.objects.aggregate(Sum('duration'))['duration__sum'],
as_dict=True,
)['d']
viz_in_last_ten = SCOTUSMap.objects.filter(
date_published__gte=ten_days_ago,
published=True,
).count()
visualizations = SCOTUSMap.objects.filter(
published=True,
deleted=False,
).annotate(Count('clusters'), ).filter(
# Ensures that we only show good stuff on homepage
clusters__count__gt=10, ).order_by(
'-date_published',
'-date_modified',
'-date_created',
)[:1]
render_dict.update({
'alerts_in_last_ten': alerts_in_last_ten,
'queries_in_last_ten': queries_in_last_ten,
'opinions_in_last_ten': opinions_in_last_ten,
'oral_arguments_in_last_ten': oral_arguments_in_last_ten,
'bulk_in_last_ten': bulk_in_last_ten,
'api_in_last_ten': api_in_last_ten,
'users_in_last_ten': users_in_last_ten,
'days_of_oa': days_of_oa,
'viz_in_last_ten': viz_in_last_ten,
'visualizations': visualizations,
'private': False, # VERY IMPORTANT!
})
return render_to_response('homepage.html', render_dict,
RequestContext(request))
else:
# User placed a search or is trying to edit an alert
if request.GET.get('edit_alert'):
# They're editing an alert
if request.user.is_anonymous():
return HttpResponseRedirect(
"{path}?next={next}{encoded_params}".format(
path=reverse('sign-in'),
next=request.path,
encoded_params=quote("?" +
request.GET.urlencode())))
else:
alert = get_object_or_404(Alert,
pk=request.GET.get('edit_alert'),
user=request.user)
alert_form = CreateAlertForm(
instance=alert,
initial={'query': get_string_sans_alert},
user=request.user,
)
else:
# Just a regular search
if not is_bot(request):
tally_stat('search.results')
# Create bare-bones alert form.
alert_form = CreateAlertForm(initial={
'query': get_string,
'rate': "dly"
},
user=request.user)
render_dict.update(do_search(request))
render_dict.update({'alert_form': alert_form})
return render_to_response(
'search.html',
render_dict,
RequestContext(request),
)
def view_opinion(request, pk, _):
"""Using the cluster ID, return the cluster of opinions.
We also test if the cluster ID is a favorite for the user, and send data
if needed. If it's a favorite, we send the bound form for the favorite so
it can populate the form on the page. If it is not a favorite, we send the
unbound form.
"""
# Look up the court, cluster, title and favorite information
cluster = get_object_or_404(OpinionCluster, pk=pk)
title = ', '.join([
s for s in [
trunc(best_case_name(cluster), 100, ellipsis="..."),
cluster.citation_string,
] if s.strip()
])
has_downloads = False
for sub_opinion in cluster.sub_opinions.all():
if sub_opinion.local_path or sub_opinion.download_url:
has_downloads = True
break
get_string = search_utils.make_get_string(request)
try:
fave = Favorite.objects.get(cluster_id=cluster.pk, user=request.user)
except (ObjectDoesNotExist, TypeError):
# Not favorited or anonymous user
favorite_form = FavoriteForm(
initial={
'cluster_id': cluster.pk,
'name': trunc(best_case_name(cluster), 100, ellipsis='...'),
})
else:
favorite_form = FavoriteForm(instance=fave)
if not is_bot(request):
# Get the citing results from Solr for speed. Only do this for humans
# to save on disk usage.
conn = sunburnt.SolrInterface(settings.SOLR_OPINION_URL, mode='r')
q = {
'q':
'cites:({ids})'.format(ids=' OR '.join([
str(pk)
for pk in (cluster.sub_opinions.values_list('pk', flat=True))
])),
'rows':
5,
'start':
0,
'sort':
'citeCount desc',
'caller':
'view_opinion',
}
citing_clusters = conn.raw_query(**q).execute()
else:
citing_clusters = None
return render(
request, 'view_opinion.html', {
'title': title,
'cluster': cluster,
'has_downloads': has_downloads,
'favorite_form': favorite_form,
'get_string': get_string,
'private': cluster.blocked,
'citing_clusters': citing_clusters,
'top_authorities': cluster.authorities[:5],
})
def show_results(request):
"""
This view can vary significantly, depending on how it is called:
- In its most simple form, it is called via GET and without any
parameters.
--> This loads the homepage.
- It might also be called with GET *with* parameters.
--> This loads search results.
- It might be called with a POST.
--> This attempts to save an alert.
It also has a few failure modes it needs to support:
- It must react properly to an invalid alert form.
- It must react properly to an invalid or failing search form.
All of these paths have tests.
"""
# Create a search string that does not contain the page numbers
get_string = make_get_string(request)
get_string_sans_alert = make_get_string(request, ['page', 'edit_alert'])
render_dict = {
'private': True,
'get_string': get_string,
'get_string_sans_alert': get_string_sans_alert,
}
if request.method == 'POST':
# The user is trying to save an alert.
alert_form = CreateAlertForm(request.POST, user=request.user)
if alert_form.is_valid():
cd = alert_form.cleaned_data
# save the alert
if request.POST.get('edit_alert'):
# check if the user can edit this, or if they are url hacking
alert = get_object_or_404(
Alert,
pk=request.POST.get('edit_alert'),
user=request.user,
)
alert_form = CreateAlertForm(cd,
instance=alert,
user=request.user)
alert_form.save()
action = "edited"
else:
alert_form = CreateAlertForm(cd, user=request.user)
alert = alert_form.save(commit=False)
alert.user = request.user
alert.save()
action = "created"
messages.add_message(request, messages.SUCCESS,
'Your alert was %s successfully.' % action)
# and redirect to the alerts page
return HttpResponseRedirect(reverse("profile_alerts"))
else:
# Invalid form. Do the search again and show them the alert form
# with the errors
render_dict.update(do_search(request))
render_dict.update({'alert_form': alert_form})
return render(request, 'search.html', render_dict)
else:
# Either a search or the homepage
if len(request.GET) == 0:
# No parameters --> Homepage.
if not is_bot(request):
tally_stat('search.homepage_loaded')
# Ensure we get nothing from the future.
request.GET = request.GET.copy() # Makes it mutable
request.GET['filed_before'] = date.today()
homepage_cache_key = 'homepage-data'
homepage_dict = cache.get(homepage_cache_key)
if homepage_dict is not None:
return render(request, 'homepage.html', homepage_dict)
# Load the render_dict with good results that can be shown in the
# "Latest Cases" section
render_dict.update(
do_search(request,
rows=5,
order_by='dateFiled desc',
facet=False))
# Get the results from the oral arguments as well
oa_dict = do_search(request,
rows=5,
order_by='dateArgued desc',
type='oa',
facet=False)
render_dict.update({'results_oa': oa_dict['results']})
# But give it a fresh form for the advanced search section
render_dict.update({'search_form': SearchForm(request.GET)})
# Get a bunch of stats.
render_dict.update(get_homepage_stats())
six_hours = 60 * 60 * 6
cache.set(homepage_cache_key, render_dict, six_hours)
return render(request, 'homepage.html', render_dict)
else:
# User placed a search or is trying to edit an alert
if request.GET.get('edit_alert'):
# They're editing an alert
if request.user.is_anonymous():
return HttpResponseRedirect(
"{path}?next={next}{encoded_params}".format(
path=reverse('sign-in'),
next=request.path,
encoded_params=quote("?" +
request.GET.urlencode())))
else:
alert = get_object_or_404(Alert,
pk=request.GET.get('edit_alert'),
user=request.user)
alert_form = CreateAlertForm(
instance=alert,
initial={'query': get_string_sans_alert},
user=request.user,
)
else:
# Just a regular search
if not is_bot(request):
tally_stat('search.results')
# Create bare-bones alert form.
alert_form = CreateAlertForm(initial={
'query': get_string,
'rate': "dly"
},
user=request.user)
render_dict.update(do_search(request))
# Set the value to the query as a convenience
alert_form.fields['name'].widget.attrs['value'] = \
render_dict['search_summary_str']
render_dict.update({'alert_form': alert_form})
return render(request, 'search.html', render_dict)
