def create_and_save_election_object_jformat(
election_type, election_websurvey, election_date, slug, human_friendly_name):
"""
Create a new election given the election information
Keyword Arguments
election_type -- indicates whether the election is a general election of by election
election_websurvey -- the link to the election's websurvey
election_date - the date and time of the election
slug - the slug for the election
human_friendly_name -- the human friendly name of the election
Return
the election object
"""
election = Election(slug=slug, election_type=election_type, date=election_date,
websurvey=election_websurvey, human_friendly_name=human_friendly_name)
election.save()
logger.info(f"[elections/save_new_election_obj_jformat.py create_and_save_election_object_jformat()] "
f"saving new election object {election} with date {election_date}, election_type {election_type} "
f"websurvey link {election_websurvey}, slug {slug} and "
f"human friendly name {human_friendly_name} "
)
return election
def test_is_election_day(self):
today = Election(election_date=datetime.date(2021, 5, 6))
future = Election(election_date=datetime.date(2021, 5, 7))
past = Election(election_date=datetime.date(2021, 5, 5))
assert today.is_election_day is True
assert future.is_election_day is False
assert past.is_election_day is False
def get_counts(for_json=True):
election_id_to_candidates = {}
qs = (Membership.objects.filter(
role=F("post_election__election__candidate_membership_role")).values(
"post_election__election").annotate(
count=Count("post_election__election")))
for d in qs:
election_id_to_candidates[d["post_election__election"]] = d["count"]
grouped_elections = Election.group_and_order_elections(for_json=for_json)
for era_data in grouped_elections:
for date, elections in era_data["dates"].items():
for role_data in elections:
for election_data in role_data["elections"]:
e = election_data["election"]
total = election_id_to_candidates.get(e.id, 0)
election_counts = {
"id": e.slug,
"html_id": e.slug.replace(".", "-"),
"name": e.name,
"total": total,
}
election_data.update(election_counts)
del election_data["election"]
return grouped_elections
def _build(self, record):
def merge_dicts(d1, d2):
d3 = d1.copy()
d3.update(d2)
return d3
try:
return Election.private_objects.get(
election_id=record["election_id"])
except Election.DoesNotExist:
# return an instance of elections.models.Election
# but don't persist it to the DB yet.
# The calling code is responsible for calling .save()
return Election(**merge_dicts(
record,
{
"poll_open_date": self.date,
"election_type": self.election_type,
"election_subtype": self.subtype,
"organisation": self.organisation,
"division": self.division,
"elected_role": self.get_elected_role(),
"voting_system": self.get_voting_system(),
},
))
def get_counts(for_json=True):
election_id_to_candidates = {}
qs = Membership.objects.filter(
role=F('post_election__election__candidate_membership_role')).values(
'post_election__election').annotate(
count=Count('post_election__election'))
for d in qs:
election_id_to_candidates[d['post_election__election']] = d['count']
grouped_elections = Election.group_and_order_elections(for_json=for_json)
for era_data in grouped_elections:
for date, elections in era_data['dates'].items():
for role_data in elections:
for election_data in role_data['elections']:
e = election_data['election']
total = election_id_to_candidates.get(e.id, 0)
election_counts = {
'id': e.slug,
'html_id': e.slug.replace('.', '-'),
'name': e.name,
'total': total,
}
election_data.update(election_counts)
del election_data['election']
return grouped_elections
def test_election_just_general_elections(self):
self.sp_c_election.delete()
self.sp_r_election.delete()
with self.assertNumQueries(1):
self.assertEqual(
Election.group_and_order_elections(),
[
{
'current': True,
'roles': [
{
'role': 'Member of Parliament',
'elections': [
{'election': self.election},
]
},
]
},
{
'current': False,
'roles': [
{
'role': 'Member of Parliament',
'elections': [
{'election': self.earlier_election},
]
}
]
},
]
)
def test_election_just_general_elections(self):
self.sp_c_election.delete()
self.sp_r_election.delete()
with self.assertNumQueries(1):
self.assertEqual(Election.group_and_order_elections(), [
{
'current':
True,
'roles': [
{
'role': 'Member of Parliament',
'elections': [
{
'election': self.election
},
]
},
]
},
{
'current':
False,
'roles': [{
'role':
'Member of Parliament',
'elections': [
{
'election': self.earlier_election
},
]
}]
},
])
def test_election_just_general_elections(self):
self.sp_c_election.delete()
self.sp_r_election.delete()
with self.assertNumQueries(1):
self.assertEqual(
Election.group_and_order_elections(),
[
{
'current': True,
'dates': OrderedDict([
(self.local_election.election_date, [{
'role': 'Local Councillor', 'elections': [
{'election': self.local_election}
]
}]),
(self.election.election_date, [{
'role': 'Member of Parliament', 'elections': [
{'election': self.election}
]
}])
])
},
{
'current': False,
'dates': OrderedDict([
(self.earlier_election.election_date, [{
'role': 'Member of Parliament',
'elections': [
{'election': self.earlier_election}
]
}])
])
}
]
)
def test_election_grouping_with_posts(self):
with self.assertNumQueries(2):
self.assertEqual(
Election.group_and_order_elections(include_posts=True), [
{
'current':
True,
'roles': [{
'role':
'Member of Parliament',
'elections': [
{
'election':
self.election,
'posts': [
self.camberwell_post_extra,
self.dulwich_post_extra,
self.edinburgh_east_post_extra,
self.edinburgh_north_post_extra,
]
},
]
}, {
'role':
'Member of the Scottish Parliament',
'elections': [
{
'election': self.sp_c_election,
'posts': []
},
{
'election': self.sp_r_election,
'posts': []
},
]
}]
},
{
'current':
False,
'roles': [{
'role':
'Member of Parliament',
'elections': [
{
'election':
self.earlier_election,
'posts': [
self.camberwell_post_extra,
self.dulwich_post_extra,
self.edinburgh_east_post_extra,
self.edinburgh_north_post_extra,
]
},
]
}]
},
])
def get_common_context(request):
context_dict = get_message_dict(request)
context_dict.update({
'request': request,
'main_nav': 'members',
'elections': Election.get_current_elections(),
'subnav': 'elections',
})
return context_dict
def get_context_data(self, **kwargs):
context = super(HelpApiView, self).get_context_data(**kwargs)
context['grouped_elections'] = Election.group_and_order_elections()
context['help_results_url'] = reverse('help-results')
context['base_api_url'] = self.request.build_absolute_uri(
reverse('api-root', kwargs={'version': 'v0.9'}))
return context
def get_context_data(self, **kwargs):
context = super(HelpApiView, self).get_context_data(**kwargs)
context['grouped_elections'] = Election.group_and_order_elections()
context['base_api_url'] = self.request.build_absolute_uri(
reverse('api-root', kwargs={'version': 'v0.9'})
)
return context
def create_elections(request):
if not request.user.is_superuser:
request.session['error_message'] = 'Invalid Action.'
return redirect('elections:index')
term = AcademicTerm.get_current_term()
e = Election.create_election_for_next_term(term)
request.session['success_message'] = 'Elections Created'
return HttpResponseRedirect(
reverse('elections:list', args=(e.id,))
)
def test_election_grouping_with_posts(self):
with self.assertNumQueries(2):
self.assertEqual(
Election.group_and_order_elections(include_posts=True),
[
{
'current': True,
'roles': [
{
'role': 'Member of Parliament',
'elections': [
{
'election': self.election,
'posts': [
self.camberwell_post_extra,
self.dulwich_post_extra,
self.edinburgh_east_post_extra,
self.edinburgh_north_post_extra,
]
},
]
},
{
'role': 'Member of the Scottish Parliament',
'elections': [
{'election': self.sp_c_election, 'posts': []},
{'election': self.sp_r_election, 'posts': []},
]
}
]
},
{
'current': False,
'roles': [
{
'role': 'Member of Parliament',
'elections': [
{
'election': self.earlier_election,
'posts': [
self.camberwell_post_extra,
self.dulwich_post_extra,
self.edinburgh_east_post_extra,
self.edinburgh_north_post_extra,
]
},
]
}
]
},
]
)
def test_election_grouping_with_posts(self):
with self.assertNumQueries(2):
self.assertEqual(
Election.group_and_order_elections(include_posts=True), [{
'current':
True,
'dates':
OrderedDict([(datetime.date(2016, 5, 5), [{
'role':
'Member of the Scottish Parliament',
'elections': [{
'posts': [],
'election': self.sp_c_election
}, {
'posts': [],
'election': self.sp_r_election
}]
}]),
(self.election.election_date, [{
'role':
'Member of Parliament',
'elections': [{
'posts': [
self.camberwell_post_extra,
self.dulwich_post_extra,
self.edinburgh_east_post_extra,
self.edinburgh_north_post_extra,
],
'election':
self.election
}]
}])])
}, {
'current':
False,
'dates':
OrderedDict([(self.earlier_election.election_date, [{
'role':
'Member of Parliament',
'elections': [{
'posts': [
self.camberwell_post_extra,
self.dulwich_post_extra,
self.edinburgh_east_post_extra,
self.edinburgh_north_post_extra,
],
'election':
self.earlier_election
}]
}])])
}])
def test_election_just_general_elections(self):
self.sp_c_election.delete()
self.sp_r_election.delete()
with self.assertNumQueries(1):
self.assertEqual(
Election.group_and_order_elections(),
[
{
"current_or_future":
True,
"dates":
OrderedDict([
(
self.local_election.election_date,
[{
"role":
"Local Councillor",
"elections": [{
"election":
self.local_election
}],
}],
),
(
self.election.election_date,
[{
"role": "Member of Parliament",
"elections": [{
"election": self.election
}],
}],
),
]),
},
{
"current_or_future":
False,
"dates":
OrderedDict([(
self.earlier_election.election_date,
[{
"role":
"Member of Parliament",
"elections": [{
"election": self.earlier_election
}],
}],
)]),
},
],
)
def get_context_data(self, **kwargs):
context = super(HelpResultsView, self).get_context_data(**kwargs)
context['all_results_exists'] = self.results_file_exists(None)
context['grouped_elections'] = Election.group_and_order_elections()
for era_data in context['grouped_elections']:
for role_data in era_data['roles']:
for election_dict in role_data['elections']:
election = election_dict['election']
election_dict['results_file_exists'] = \
self.results_file_exists(election.slug)
return context
def get_context_data(self, **kwargs):
context = super(HelpResultsView, self).get_context_data(**kwargs)
context['all_results_exists'] = self.results_file_exists(None)
context['grouped_elections'] = Election.group_and_order_elections()
for era_data in context['grouped_elections']:
for role_data in era_data['roles']:
for election_dict in role_data['elections']:
election = election_dict['election']
election_dict['results_file_exists'] = \
self.results_file_exists(election.slug)
return context
def test_election_grouping(self):
with self.assertNumQueries(1):
self.assertEqual(
Election.group_and_order_elections(),
[
{
'current': True,
'dates': OrderedDict([
(datetime.date(2016, 5, 5), [
{
'role': 'Local Councillor',
'elections': [
{'election': self.local_election},
]
},
{
'role': 'Member of the Scottish Parliament',
'elections': [
{'election': self.sp_c_election},
{'election': self.sp_r_election},
]
},
]),
(self.election.election_date, [
{
'role': 'Member of Parliament',
'elections': [
{'election': self.election}
]
}
])
])
},
{
'current': False,
'dates': OrderedDict([
(self.earlier_election.election_date, [
{
'role': 'Member of Parliament',
'elections': [
{'election':self.earlier_election}
]
}
])
])
}
]
)
def index(request):
""" The landing page for the elections app.
This page shows the currently active elections.
If there is only one active election, it redirects to the nominations
list instead.
"""
request.session['current_page'] = request.path
template = loader.get_template('elections/index.html')
current_elections = Election.get_current_elections()
context_dict = {}
if current_elections.count() == 1:
return redirect('elections:list', current_elections[0].id)
context_dict.update(get_common_context(request))
context_dict.update(get_permissions(request.user))
return HttpResponse(template.render(context_dict, request))
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["all_results_exists"] = self.results_file_exists(None)
context["grouped_elections"] = Election.group_and_order_elections()
for era_data in context["grouped_elections"]:
for date, elections in era_data["dates"].items():
for role_data in elections:
for election_dict in role_data["elections"]:
election = election_dict["election"]
election_dict[
"results_file_exists"
] = self.results_file_exists(election.slug)
return context
def test_election_grouping(self):
with self.assertNumQueries(1):
self.assertEqual(Election.group_and_order_elections(), [
{
'current':
True,
'roles': [{
'role': 'Member of Parliament',
'elections': [
{
'election': self.election
},
]
}, {
'role':
'Member of the Scottish Parliament',
'elections': [
{
'election': self.sp_c_election
},
{
'election': self.sp_r_election
},
]
}]
},
{
'current':
False,
'roles': [{
'role':
'Member of Parliament',
'elections': [
{
'election': self.earlier_election
},
]
}]
},
])
def get_counts():
election_id_to_candidates = {
d['extra__election']: d['count']
for d in Membership.objects \
.filter(role=F('extra__election__candidate_membership_role')) \
.values('extra__election') \
.annotate(count=Count('extra__election'))
}
grouped_elections = Election.group_and_order_elections()
past_elections = [
election_data['election']
for era_data in grouped_elections
for role_data in era_data['roles']
for election_data in role_data['elections']
if not era_data['current']
]
for era_data in grouped_elections:
for role_data in era_data['roles']:
for election_data in role_data['elections']:
e = election_data['election']
total = election_id_to_candidates.get(e.id, 0)
election_counts = {
'id': e.slug,
'html_id': e.slug.replace('.', '-'),
'name': e.name,
'total': total,
}
if era_data['current']:
election_counts['prior_elections'] = [
get_prior_election_data(
total, e,
election_id_to_candidates.get(pe.id, 0), pe
)
for pe in past_elections
if pe.for_post_role == e.for_post_role
]
election_data.update(election_counts)
del election_data['election']
return grouped_elections
def get_counts():
election_id_to_candidates = {
d['extra__election']: d['count']
for d in Membership.objects \
.filter(role=F('extra__election__candidate_membership_role')) \
.values('extra__election') \
.annotate(count=Count('extra__election'))
}
grouped_elections = Election.group_and_order_elections()
past_elections = [
election_data['election']
for era_data in grouped_elections
for role_data in era_data['roles']
for election_data in role_data['elections']
if not era_data['current']
]
for era_data in grouped_elections:
for role_data in era_data['roles']:
for election_data in role_data['elections']:
e = election_data['election']
total = election_id_to_candidates.get(e.id, 0)
election_counts = {
'id': e.slug,
'html_id': e.slug.replace('.', '-'),
'name': e.name,
'total': total,
}
if era_data['current']:
election_counts['prior_elections'] = [
get_prior_election_data(
total, e,
election_id_to_candidates.get(pe.id, 0), pe
)
for pe in past_elections
if pe.for_post_role == e.for_post_role
]
election_data.update(election_counts)
del election_data['election']
return grouped_elections
def test_election_grouping(self):
with self.assertNumQueries(1):
self.assertEqual(
Election.group_and_order_elections(),
[
{
'current': True,
'roles': [
{
'role': 'Member of Parliament',
'elections': [
{'election': self.election},
]
},
{
'role': 'Member of the Scottish Parliament',
'elections': [
{'election': self.sp_c_election},
{'election': self.sp_r_election},
]
}
]
},
{
'current': False,
'roles': [
{
'role': 'Member of Parliament',
'elections': [
{'election': self.earlier_election},
]
}
]
},
]
)
def setUp(self):
self.election = Election(slug="not.city-of-london")
self.city_of_london_election = Election(slug="local.city-of-london")
def get_dropdowns(user):
# NOTE: subsub navs will not show in dropdowns but will
# show in the secondary bar (currently just for member resources).
# Three levels deep is max supported
dropdowns = {
'about': [],
'event_cal': [],
'outreach': [],
'member_resources': [],
'corporate': [],
'publications': [],
}
# about: currently no permissions dependence
dropdowns['about'].append({
'subnav': 'about',
'link_name': 'About',
'link': reverse('about:index')
})
dropdowns['about'].append({
'subnav': 'joining',
'link_name': 'Joining',
'link': reverse('about:eligibility')
})
dropdowns['about'].append({
'subnav': 'leadership',
'link_name': 'Leadership',
'link':
reverse('about:leadership')
})
dropdowns['about'].append({
'subnav': 'bylaws',
'link_name': 'Chapter Bylaws',
'link': reverse('about:bylaws')
})
# event_cal
dropdowns['event_cal'].append({
'subnav': 'gcal',
'link_name': 'Google Calendar',
'link': reverse('event_cal:index')
})
dropdowns['event_cal'].append({
'subnav': 'list',
'link_name': 'Event List',
'link': reverse('event_cal:list')
})
dropdowns['event_cal'].append({
'subnav': 'my_events',
'link_name': 'My Events',
'link': reverse('event_cal:my_events')
})
if hasattr(user, 'userprofile') and user.userprofile.is_member():
dropdowns['event_cal'].append({
'subnav': 'tutoring_form',
'link_name': 'Submit Tutoring Form',
'link': reverse('event_cal:submit_tutoring_form')
})
if Permissions.can_view_calendar_admin(user):
dropdowns['event_cal'].append({
'subnav': 'admin',
'link_name': 'Calendar Admin',
'link': reverse('event_cal:calendar_admin')
})
# outreach: currently no permissions dependence
dropdowns['outreach'].append({
'subnav': 'index',
'link_name': 'Outreach',
'link': reverse('outreach:index')
})
dropdowns['outreach'].append({
'subnav': 'mindset',
'link_name': 'MindSET',
'link': reverse('outreach:mindset')
})
dropdowns['outreach'].append({
'subnav': 'tutoring',
'link_name': 'Tutoring',
'link': reverse('outreach:tutoring')
})
for event_type in OutreachEventType.get_active():
dropdowns['outreach'].append({
'subnav': event_type.url_stem,
'link_name': event_type.get_tab_name(),
'link': reverse('outreach:outreach_event',
args=[event_type.url_stem])
})
# electees: subnav of member_resources
electee_dropdowns = []
if Permissions.can_manage_electee_progress(user):
electee_dropdowns.append({
'subnav': 'groups',
'link_name': 'Manage Electee Teams',
'link': reverse('electees:edit_electee_groups')
})
electee_dropdowns.append({
'subnav': 'members',
'link_name': 'Edit Electee Teams\' Members',
'link': reverse('electees:edit_electee_group_membership')
})
electee_dropdowns.append({
'subnav': 'points',
'link_name': 'Edit Electee Team Points',
'link': reverse('electees:edit_electee_group_points')
})
# elections: subnav of member_resources, depends on existing elections
elections = Election.get_current_elections()
elections_dropdowns = []
for election in elections:
if elections.count() > 1:
elections_dropdowns.append({
'subnav': 'list'+unicode(election.id),
'link_name': 'Nomination List (%s)' % (
election.term.get_abbreviation()),
'link': reverse('elections:list', args=[election.id])
})
elections_dropdowns.append({
'subnav': 'my_nominations' + unicode(election.id),
'link_name': 'My Nominations (%s)' % (
election.term.get_abbreviation()),
'link': reverse('elections:my_nominations',
args=[election.id])
})
# member_resources
if hasattr(user, 'userprofile') and user.userprofile.is_member():
dropdowns['member_resources'].append({
'subnav': 'member_profiles',
'link_name': 'Member Profiles',
'link': reverse('member_resources:member_profiles')
})
else:
dropdowns['member_resources'].append({
'subnav': 'member_profiles',
'link_name': 'Members Resources',
'link': reverse('member_resources:index')
})
if hasattr(user, 'userprofile') and user.userprofile.is_member():
dropdowns['member_resources'].append({
'subnav': 'view_own_progress',
'link_name': 'Track My Progress',
'link': reverse('member_resources:view_progress',
args=[user.username])
})
if Permissions.can_view_more_than_own_progress(user):
dropdowns['member_resources'].append({
'subnav': 'view_others_progress',
'link_name': 'View Others\' Progress',
'link': reverse('member_resources:view_progress_list')
})
if (Permissions.can_manage_misc_reqs(user) or
Permissions.can_change_requirements(user)):
dropdowns['member_resources'].append({
'subnav': 'misc_reqs',
'link_name': 'Membership Admin',
'link': reverse('member_resources:view_misc_reqs')
})
if hasattr(user, 'userprofile'):
dropdowns['member_resources'].append({
'subnav': 'playground',
'link_name': 'TBPlayground',
'link': reverse('fora:index')
})
dropdowns['member_resources'].append({
'subnav': 'history',
'link_name': 'Access History',
'link': reverse('member_resources:access_history')
})
dropdowns['member_resources'].append({
'subnav': 'electees',
'link_name': 'Electee Resources',
'link': reverse('electees:view_electee_groups'),
'subsubnav': electee_dropdowns
})
dropdowns['member_resources'].append({
'subnav': 'elections',
'link_name': 'Elections',
'link': reverse('elections:index'),
'subsubnav': elections_dropdowns
})
if Permissions.can_manage_website(user):
dropdowns['member_resources'].append({
'subnav': 'website',
'link_name': 'Manage Website',
'link': reverse('member_resources:manage_website')
})
# corporate
dropdowns['corporate'].append({
'subnav': 'index',
'link_name': 'For Companies',
'link': reverse('corporate:index')
})
dropdowns['corporate'].append({
'subnav': 'resumes',
'link_name': u'Member R\u00e9sum\u00e9s',
'link': reverse('corporate:resumes')
})
# publications
dropdowns['publications'].append({
'subnav': 'news',
'link_name': 'Blog',
'link': reverse('history:index')
})
dropdowns['publications'].append({
'subnav': 'cornerstone',
'link_name': 'The Cornerstone',
'link': reverse('history:cornerstone_view')
})
dropdowns['publications'].append({
'subnav': 'alumni_news',
'link_name': 'Alumni Newsletters',
'link': reverse('history:alumninews_view')
})
if hasattr(user, 'userprofile') and user.userprofile.is_member():
dropdowns['publications'].append({
'subnav': 'project_reports',
'link_name': 'Chapter Project Reports',
'link': reverse('history:get_project_reports')
})
# bookswap
# currently none
return dropdowns
def test_election_grouping(self):
with self.assertNumQueries(1):
self.assertEqual(
Election.group_and_order_elections(),
[
{
"current_or_future":
True,
"dates":
OrderedDict([
(
datetime.date(2016, 5, 5),
[
{
"role":
"Local Councillor",
"elections": [{
"election":
self.local_election
}],
},
{
"role":
"Member of the Scottish Parliament",
"elections": [
{
"election": self.sp_c_election
},
{
"election": self.sp_r_election
},
],
},
],
),
(
self.election.election_date,
[{
"role": "Member of Parliament",
"elections": [{
"election": self.election
}],
}],
),
]),
},
{
"current_or_future":
False,
"dates":
OrderedDict([(
self.earlier_election.election_date,
[{
"role":
"Member of Parliament",
"elections": [{
"election": self.earlier_election
}],
}],
)]),
},
],
)
def test_election_grouping_with_posts(self):
camberwell_ballot = get_election_extra(self.camberwell_post,
self.election)
dulwich_ballot = get_election_extra(self.dulwich_post, self.election)
edinburgh_east_ballot = get_election_extra(self.edinburgh_east_post,
self.election)
edinburgh_north_ballot = get_election_extra(self.edinburgh_north_post,
self.election)
camberwell_earlier = get_election_extra(self.camberwell_post,
self.earlier_election)
dulwich_earlier = get_election_extra(self.dulwich_post,
self.earlier_election)
edinburgh_east_earlier = get_election_extra(self.edinburgh_east_post,
self.earlier_election)
edinburgh_north_earlier = get_election_extra(self.edinburgh_north_post,
self.earlier_election)
local_council_ballot = get_election_extra(self.local_post,
self.local_election)
with self.assertNumQueries(3):
self.assertEqual(
Election.group_and_order_elections(include_ballots=True),
[
{
"current_or_future":
True,
"dates":
OrderedDict([
(
datetime.date(2016, 5, 5),
[
{
"role":
"Local Councillor",
"elections": [{
"ballots": [local_council_ballot],
"election":
self.local_election,
}],
},
{
"role":
"Member of the Scottish Parliament",
"elections": [
{
"ballots": [],
"election": self.sp_c_election,
},
{
"ballots": [],
"election": self.sp_r_election,
},
],
},
],
),
(
self.election.election_date,
[{
"role":
"Member of Parliament",
"elections": [{
"ballots": [
camberwell_ballot,
dulwich_ballot,
edinburgh_east_ballot,
edinburgh_north_ballot,
],
"election":
self.election,
}],
}],
),
]),
},
{
"current_or_future":
False,
"dates":
OrderedDict([(
self.earlier_election.election_date,
[{
"role":
"Member of Parliament",
"elections": [{
"ballots": [
camberwell_earlier,
dulwich_earlier,
edinburgh_east_earlier,
edinburgh_north_earlier,
],
"election":
self.earlier_election,
}],
}],
)]),
},
],
)
def election(self):
return Election(slug="not.city-of-london")
def city_of_london_election(self):
return Election(slug="local.city-of-london")
def test_in_past(self):
yesterday = datetime.date.today() - datetime.timedelta(days=1)
election = Election(election_date=yesterday)
assert election.in_past is True
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["elections_and_posts"] = Election.group_and_order_elections(
include_postextraelections=True, include_noncurrent=False)
return context
def test_name_without_brackets(self, name, expected):
election = Election(name=name, any_non_by_elections=True)
assert election.name_without_brackets == expected
def test_election_grouping_with_posts(self):
camberwell_postextraelection = get_election_extra(
self.camberwell_post_extra, self.election
)
dulwich_postextraelection = get_election_extra(
self.dulwich_post_extra, self.election
)
edinburgh_east_postextraelection = get_election_extra(
self.edinburgh_east_post_extra, self.election
)
edinburgh_north_postextraelection = get_election_extra(
self.edinburgh_north_post_extra, self.election
)
camberwell_earlier = get_election_extra(
self.camberwell_post_extra, self.earlier_election
)
dulwich_earlier = get_election_extra(
self.dulwich_post_extra, self.earlier_election
)
edinburgh_east_earlier = get_election_extra(
self.edinburgh_east_post_extra, self.earlier_election
)
edinburgh_north_earlier = get_election_extra(
self.edinburgh_north_post_extra, self.earlier_election
)
local_council_pee = get_election_extra(
self.local_post, self.local_election
)
with self.assertNumQueries(4):
self.assertEqual(
Election.group_and_order_elections(include_postextraelections=True),
[
{
'current': True,
'dates': OrderedDict([
(datetime.date(2016, 5, 5), [{
'role': 'Local Councillor',
'elections': [
{
'postextraelections': [
local_council_pee
],
'election': self.local_election,
}
]
},
{
'role': 'Member of the Scottish Parliament',
'elections': [
{
'postextraelections': [],
'election': self.sp_c_election
},
{
'postextraelections': [],
'election': self.sp_r_election
}
]
}]),
(self.election.election_date, [{
'role': 'Member of Parliament',
'elections': [
{
'postextraelections': [
camberwell_postextraelection,
dulwich_postextraelection,
edinburgh_east_postextraelection,
edinburgh_north_postextraelection,
],
'election': self.election
}
]
}])
])
},
{
'current': False,
'dates': OrderedDict([
(self.earlier_election.election_date, [{
'role': 'Member of Parliament',
'elections': [
{
'postextraelections': [
camberwell_earlier,
dulwich_earlier,
edinburgh_east_earlier,
edinburgh_north_earlier,
],
'election': self.earlier_election
}
]
}])
])
}
]
)
def get_context_data(self, **kwargs):
context = super(PostListView, self).get_context_data(**kwargs)
context['elections_and_posts'] = \
Election.group_and_order_elections(include_posts=True)
return context
def test_election(self):
e = Election(
election_date=datetime.datetime.today(),
current=True,
)
e.save()
def get_context_data(self, **kwargs):
context = super(PostListView, self).get_context_data(**kwargs)
context['elections_and_posts'] = \
Election.group_and_order_elections(
include_posts=True, include_noncurrent=False)
return context
