def parse_approximate_date(s):
"""Take any reasonable date string, and return an ApproximateDate for it
>>> ad = parse_approximate_date('2014-02-17')
>>> type(ad)
<class 'django_date_extensions.fields.ApproximateDate'>
>>> ad
2014-02-17
>>> parse_approximate_date('2014-02')
2014-02-00
>>> parse_approximate_date('2014')
2014-00-00
>>> parse_approximate_date('future')
future
"""
for regexp in [
r'^(\d{4})-(\d{2})-(\d{2})$', r'^(\d{4})-(\d{2})$', r'^(\d{4})$'
]:
m = re.search(regexp, s)
if m:
return ApproximateDate(*(int(g, 10) for g in m.groups()))
if s == 'future':
return ApproximateDate(future=True)
if s:
dt = parser.parse(s,
parserinfo=localparserinfo(),
dayfirst=settings.DD_MM_DATE_FORMAT_PREFERRED)
return ApproximateDate(dt.year, dt.month, dt.day)
raise ValueError("Couldn't parse '{0}' as an ApproximateDate".format(s))
def parse_approximate_date(s):
"""Take a partial ISO 8601 date, and return an ApproximateDate for it
>>> ad = parse_approximate_date('2014-02-17')
>>> type(ad)
<class 'django_date_extensions.fields.ApproximateDate'>
>>> ad
2014-02-17
>>> parse_approximate_date('2014-02')
2014-02-00
>>> parse_approximate_date('2014')
2014-00-00
>>> parse_approximate_date('future')
future
"""
for regexp in [
r'^(\d{4})-(\d{2})-(\d{2})$', r'^(\d{4})-(\d{2})$', r'^(\d{4})$'
]:
m = re.search(regexp, s)
if m:
return ApproximateDate(*(int(g, 10) for g in m.groups()))
if s == 'future':
return ApproximateDate(future=True)
raise Exception, _("Couldn't parse '{0}' as an ApproximateDate").format(s)
def test_mp_with_two_constituencies(self):
Position.objects.create(
category='political',
person=self.person,
place=self.constituency,
organisation=self.na,
title=self.na_member_title,
start_date=ApproximateDate(2015, 1, 1),
)
Position.objects.create(
category='political',
person=self.person,
place=self.constituency2,
organisation=self.na,
title=self.na_member_title,
start_date=ApproximateDate(2015, 1, 2),
)
request = RequestFactory().get('/person/test-person/')
request.user = AnonymousUser()
response = KEPersonDetail.as_view()(request, slug='test-person')
self.assertEqual(len(response.context_data['constituencies']), 1)
self.assertEqual(response.context_data['constituencies'][0],
self.constituency2)
# Check that admins got mailed.
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject,
'[Django] ERROR: test-person - Too many NA memberships (2)',
)
def test_event_unpublished_with_future_and_past_dates(self):
future_date = timezone.now() + timedelta(days=1)
past_date = timezone.now() - timedelta(days=1)
# make the event date in the future
self.event_4.date = ApproximateDate(year=future_date.year,
month=future_date.month,
day=future_date.day)
self.event_4.save()
# Check if accessing unpublished page renders the event_not_live page
url = '/' + self.event_4.page_url + '/'
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
# Check if website is returning correct content
self.assertIn('will be coming soon', str(resp.content),
'Incorrect content')
# make the event date in the past
self.event_4.date = ApproximateDate(year=past_date.year,
month=past_date.month,
day=past_date.day)
self.event_4.save()
# Check if accessing unpublished page renders the event_not_live page
url = '/' + self.event_4.page_url + '/'
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
# Check if website is returning correct content
self.assertIn('has already happened', str(resp.content),
'Incorrect content')
def handle_noargs(self, **options):
# acn, anpp, cpc
old_party_slugs = (
'action-congress-of-nigeria',
'all-nigeria-peoples-party',
'congress-for-progressive-change',
)
change_date = datetime.date(2013, 7, 31)
old_party_end = ApproximateDate(2013, 7, 30)
new_party_start = ApproximateDate(2013, 7, 31)
new_party_slug = 'all-progressives-congress-apc'
new_organisation = Organisation.objects.get(slug=new_party_slug)
positions = (Position.objects.filter(
title__slug='member',
organisation__slug__in=old_party_slugs,
).currently_active(when=change_date))
# Not using a bulk update because we want to the save
# method of the Positions to be called
for position in positions:
position.end_date = old_party_end
position.save()
# Blank the primary key of the Position so that it will
# get a new one when saved.
position.pk = None
position.start_date = new_party_start
position.end_date = None
position.organisation = new_organisation
position.save()
def test_offer_help_email_form_logic(self):
""" Test event filtering logic for thank you emails depending on their application form. """
now = timezone.now()
in_six_weeks = now + timezone.timedelta(weeks=6)
@mock.patch('core.management.commands.handle_emails.send_mail')
def _would_send_email(event, mock_send_mail):
""" Return true if given event would currently trigger an "offer help" email. """
handle_emails.send_offer_help_emails()
if mock_send_mail.call_count == 0:
return False
calls = mock_send_mail.call_args_list
mock_send_mail.reset_mock()
return any(event.city in send_kwargs['subject']
for _, send_kwargs in calls)
# Test one event with no form, should send an email
event = Event.objects.create(city="Test City",
is_on_homepage=True,
date=in_six_weeks,
is_page_live=True)
self.assertTrue(_would_send_email(event))
# Event with a rough date at least a month in the future should also send an email
event.date = ApproximateDate(year=in_six_weeks.year,
month=in_six_weeks.month)
event.save()
self.assertTrue(_would_send_email(event))
# Event with a start date in the past shouldn't trigger an email
event.date = now - timezone.timedelta(days=1)
event.offer_help_email_sent = None
event.save()
self.assertFalse(_would_send_email(event))
# Nor should an event with an uncertain date in the current month.
event.date = ApproximateDate(year=now.year, month=now.month)
event.offer_help_email_sent = None
event.save()
self.assertFalse(_would_send_email(event))
# Event now has a form, no email should be sent.
event.date = in_six_weeks
event.save()
Form.objects.create(event=event)
self.assertFalse(_would_send_email(event))
# Set page to not live, email should be sent again
event.is_page_live = False
event.save()
self.assertTrue(_would_send_email(event))
# Remove from homepage, no email should be sent.
event.is_on_homepage = False
event.offer_help_email_sent = None
event.save()
self.assertFalse(_would_send_email(event))
def test_event_unpublished_with_future_and_past_dates(client, no_date_event):
future_date = timezone.now() + timedelta(days=1)
past_date = timezone.now() - timedelta(days=1)
# make the event date in the future
no_date_event.date = ApproximateDate(
year=future_date.year, month=future_date.month, day=future_date.day)
no_date_event.save()
# Check if accessing unpublished page renders the event_not_live page
url = '/' + no_date_event.page_url + '/'
resp = client.get(url)
assert resp.status_code == 200
# Check if website is returning correct content
assert 'will be coming soon' in str(resp.content)
# make the event date in the past
no_date_event.date = ApproximateDate(
year=past_date.year, month=past_date.month, day=past_date.day)
no_date_event.save()
# Check if accessing unpublished page renders the event_not_live page
url = '/' + no_date_event.page_url + '/'
resp = client.get(url)
assert resp.status_code == 200
# Check if website is returning correct content
assert 'has already happened' in str(resp.content)
def change_date(d, field):
if len(d) == 4:
return '%s-00-00' % d
elif len(d) == 7:
slices = d.split('-')
if len(slices) != 2:
raise serializers.ValidationError({field: 'Wrong date format.'})
else:
year = int(slices[0])
month = int(slices[1])
try:
ApproximateDate(year=year, month=month, day=0)
return "%s-00" % d
except ValueError:
raise serializers.ValidationError(
{field: 'Wrong date format.'})
elif len(d) == 10:
slices = d.split('-')
if len(slices) != 3:
raise serializers.ValidationError({field: 'Wrong date format.'})
else:
year = int(slices[0])
month = int(slices[1])
day = int(slices[2])
try:
ApproximateDate(year=year, month=month, day=day)
return d
except ValueError:
raise serializers.ValidationError(
{field: 'Wrong date format.'})
else:
raise serializers.ValidationError({field: 'Wrong date format.'})
def test_list_date(self):
"""
Document.list_date() should return formatted date with separators and unknown elements filled with '?'
ApproximateDateField won't allow a date without a year, or a date with just a year and a day,
so don't bother with those
"""
# If no date, list_date() should return '(Undated)'
expected = '(Undated)'
self.assertEqual(self.test_document.list_date(), expected,
"If no date, Document.list_date() should return '{}'".format(expected))
# If year only, list_date() should return year-??-??
document = self.model.objects.create(source=self.source, writer=self.writer,
date=ApproximateDate(1864))
expected = '1864-??-??'
self.assertEqual(document.list_date(), expected,
"If year only, Document.list_date() should return '{}'".format(expected))
# If year and month only, list_date() should return year-month-??
document = self.model.objects.create(source=self.source, writer=self.writer,
date=ApproximateDate(1864, 6))
expected = '1864-06-??'
self.assertEqual(document.list_date(), expected,
"If year and month only, Document.list_date() should return '{}'".format(expected))
# If year, month, and day, list_date() should return year-month-day
document = self.model.objects.create(source=self.source, writer=self.writer,
date=ApproximateDate(1864, 6, 15))
expected = '1864-06-15'
self.assertEqual(document.list_date(), expected,
"If year, month, and day, Document.list_date() should return '{}'".format(expected))
def update_parties(person, api_party, **options):
current_party_positions = person.position_set.all().currently_active().filter(title__slug='member').filter(organisation__kind__slug='party')
if 'name' in api_party:
# Then we should be checking that a valid party membership
# exists, or create a new one otherwise:
api_party_name = api_party['name']
mz_party = get_matching_party(api_party_name, **options)
need_to_create_party_position = True
for party_position in (p for p in current_party_positions if p.organisation == mz_party):
# If there's a current position in this party, that's fine
# - just make sure that the end_date is 'future':
party_position.end_date = ApproximateDate(future=True)
maybe_save(party_position, **options)
need_to_create_party_position = False
for party_position in (p for p in current_party_positions if p.organisation != mz_party):
# These shouldn't be current any more - end them when we
# got the new data:
party_position.end_date = new_data_approximate_date
maybe_save(party_position, **options)
if need_to_create_party_position:
new_position = Position(title=PositionTitle.objects.get(name='Member'),
organisation=mz_party,
category='political',
person=person,
start_date=new_data_approximate_date,
end_date=ApproximateDate(future=True))
maybe_save(new_position, **options)
else:
# If there's no party specified, end all current party positions:
for party_position in current_party_positions:
party_position.end_date = new_data_approximate_date
maybe_save(party_position, **options)
def test_from_soon_to_future(self):
position = models.Position.objects.create(
person=self.person,
organisation=self.organisation,
start_date=ApproximateDate(year=2050, month=12, day=25),
end_date=ApproximateDate(future=True))
current_positions = models.Position.objects.all().currently_active()
self.assertEqual([], list(current_positions))
def approx_date_from_entry(entry):
if entry is None:
return None
if entry == 'future':
return ApproximateDate(future=True)
if entry == 'past':
return ApproximateDate(past=True)
return ApproximateDate(year=int(entry))
def test_from_past_not_current(self):
position = models.Position.objects.create(
person=self.person,
organisation=self.organisation,
start_date=ApproximateDate(past=True),
end_date=ApproximateDate(year=2010, month=1, day=1))
current_positions = models.Position.objects.all().currently_active()
self.assertEqual([], list(current_positions))
def setUp(self):
super(DownloadMPsTest, self).setUp()
self.mp = Person.objects.create(
legal_name="Jimmy Stewart", slug="jimmy-stewart", email="*****@*****.**"
)
# Create MP position at the National Assembly
Position.objects.create(
person=self.mp,
organisation=self.na,
start_date=ApproximateDate(past=True),
end_date=ApproximateDate(future=True),
title=self.member,
)
# MP currently active position at the DA
Position.objects.create(
person=self.mp,
organisation=self.da,
start_date=ApproximateDate(past=True),
end_date=ApproximateDate(future=True),
title=self.member,
)
# MP contact number
Contact.objects.create(
content_type=ContentType.objects.get_for_model(self.mp),
object_id=self.mp.id,
kind=self.voice_kind,
value="987654321",
preferred=True,
)
Contact.objects.create(
content_type=ContentType.objects.get_for_model(self.mp),
object_id=self.mp.id,
kind=self.cell_kind,
value="5555",
preferred=True,
)
Contact.objects.create(
content_type=ContentType.objects.get_for_model(self.mp),
object_id=self.mp.id,
kind=self.twitter_kind,
value="@jimmysteward",
preferred=True,
)
Contact.objects.create(
content_type=ContentType.objects.get_for_model(self.mp),
object_id=self.mp.id,
kind=self.facebook_kind,
value="Jimmy Steward",
preferred=True,
)
Contact.objects.create(
content_type=ContentType.objects.get_for_model(self.mp),
object_id=self.mp.id,
kind=self.linkedin_kind,
value="jimmy_steward",
preferred=True,
)
def queryset(self, request, queryset):
if self.value():
year = int(self.value())
start_date = ApproximateDate(year=year, month=0, day=0)
end_date = ApproximateDate(year=year, month=12, day=31)
return queryset.filter(date__gte=start_date).filter(
date__lte=end_date)
else:
return queryset
def test_normal_current(self):
position = models.Position.objects.create(
person=self.person,
organisation=self.organisation,
start_date=ApproximateDate(year=2000, month=1, day=1),
end_date=ApproximateDate(year=2100, month=12, day=31),
)
current_positions = models.Position.objects.all().currently_active()
self.assertEqual([position], list(current_positions))
def test_short_near_future(self):
position = models.Position.objects.create(
person=self.person,
organisation=self.organisation,
start_date=ApproximateDate(year=2050, month=1, day=1),
end_date=ApproximateDate(year=2050, month=6, day=30),
)
current_positions = models.Position.objects.all().currently_active()
self.assertEqual([], list(current_positions))
def test_short_recent_past(self):
position = models.Position.objects.create(
person=self.person,
organisation=self.organisation,
start_date=ApproximateDate(year=2010, month=7, day=1),
end_date=ApproximateDate(year=2010, month=12, day=31),
)
current_positions = models.Position.objects.all().currently_active()
self.assertEqual([], list(current_positions))
position.delete()
def test_popolo_place_with_session(self):
example_assembly = models.Organisation.objects.create(
name='Example Assembly',
slug='example-assembly',
kind=models.OrganisationKind.objects.create(
name='Chamber', slug='chamber'
),
started=ApproximateDate(2009),
ended=ApproximateDate(2011, 3, 20),
)
example_session = models.ParliamentarySession.objects.create(
name='Example Session',
start_date=date(1970, 7, 1),
end_date=date(1975, 12, 31),
mapit_generation=self.generation.id,
house=example_assembly,
)
self.place.parliamentary_session = example_session
self.place.save()
self.position.place = self.place
self.position.save()
data = get_popolo_data('org.example',
'http://pombola.example.org/',
inline_memberships=False)
membership = data['memberships'][0]
self.assertTrue(membership['area'])
area = membership['area']
self.assertEqual(
set(area.keys()),
set(['area_type', 'id', 'identifier', 'name', 'session'])
)
self.assertEqual(area['area_type'], 'PRV')
self.assertEqual(area['name'], 'Test Province')
self.assertEqual(
area['id'],
'mapit:{0}'.format(self.mapit_test_province.id)
)
self.assertEqual(
area['identifier'],
"http://pombola.example.org/mapit/area/{0}".format(
self.mapit_test_province.id
)
)
self.assertTrue(area['session'])
session = area['session']
self.assertEqual(session['start_date'], '1970-07-01')
self.assertEqual(session['end_date'], '1975-12-31')
self.assertEqual(session['house_name'], 'Example Assembly')
self.assertEqual(session['name'], 'Example Session')
self.assertEqual(session['house_id'], example_assembly.id)
self.assertEqual(session['id'], example_session.id)
self.assertEqual(session['mapit_generation'], self.generation.id)
def get_approximate_date(date_str):
try:
date_obj = datetime.strptime(date_str, '%d/%m/%Y')
return ApproximateDate(year=date_obj.year, month=date_obj.month, day=date_obj.day)
except ValueError:
try:
date_obj = datetime.strptime(date_str, '%m/%Y')
return ApproximateDate(year=date_obj.year, month=date_obj.month)
except ValueError:
return None
return None
def prepare_date(self, date_str):
try:
date_obj = datetime.strptime(date_str, '%d/%m/%Y')
return ApproximateDate(year=date_obj.year, month=date_obj.month, day=date_obj.day)
except ValueError:
try:
date_obj = datetime.strptime(date_str, '%m/%Y')
return ApproximateDate(year=date_obj.year, month=date_obj.month)
except ValueError:
return False
return False
def test_is_upcoming():
now = timezone.now()
now_event = Event(date=ApproximateDate(now.year, now.month, now.day))
yesterday = now - timedelta(days=1)
yesterday_event = Event(
date=ApproximateDate(yesterday.year, yesterday.month, yesterday.day))
tomorrow = now + timedelta(days=1)
tomorrow_event = Event(
date=ApproximateDate(tomorrow.year, tomorrow.month, tomorrow.day))
assert now_event.is_upcoming()
assert not yesterday_event.is_upcoming()
assert tomorrow_event.is_upcoming()
def setUp(self):
self.test_kind = OrganisationKind(name="TestKind", slug="test-kind")
self.organisation_future_ended = Organisation(
name="Test Org", slug="test-org", kind=self.test_kind, ended=ApproximateDate(future=True)
)
self.organisation_none_ended = Organisation(
name="Basic Education", slug="basic-education", kind=self.test_kind,
)
self.organisation_already_ended = Organisation(
name="NCOP Appropriations",
slug="ncop-appropriations",
kind=self.test_kind,
ended=ApproximateDate(2010,1,1),
)
def handle_noargs(self, **options):
for person in Person.objects.all():
party_positions = person.position_set.all().filter(title__slug='member').filter(organisation__kind__slug='party')
if not party_positions:
continue
most_recent_party_position = party_positions[0]
if most_recent_party_position.end_date == ApproximateDate(2012):
most_recent_party_position.end_date = ApproximateDate(future=True)
message = "2012 end_date to future for %s" % (most_recent_party_position,)
if options['commit']:
most_recent_party_position.save()
print >> sys.stderr, "Changing " + message
else:
print >> sys.stderr, "Not changing " + message + "because --commit wasn't specified"
def test_display_dates(self):
"""Check that the date that is displayed is correct"""
position = models.Position(person=self.person)
# Dates that will be used for testing
past = ApproximateDate(past=True)
y2000 = ApproximateDate(year=2000)
y2100 = ApproximateDate(year=2100)
future = ApproximateDate(future=True)
# test grid: start, end, uot
tests = (
(None, None, ""),
(None, past, "Ended"),
(None, y2000, "Ended 2000"),
(None, y2100, "Will end 2100"),
(None, future, "Ongoing"),
(past, None, "Started"),
(past, past, "Ended"),
(past, y2000, "Ended 2000"),
(past, y2100, "Will end 2100"),
(past, future, "Ongoing"),
(y2000, None, "Started 2000"),
(y2000, past, "Started 2000, now ended"),
(y2000, y2000, "2000 → 2000"),
(y2000, y2100, "2000 → 2100"),
(y2000, future, "Started 2000"),
(y2100, None, "Will start 2100"),
(y2100, y2100, "2100 → 2100"),
(y2100, future, "Will start 2100"),
(future, None, "Not started yet"),
(future, future, "Not started yet"),
# These are impossible, but we don't validate against them. Best check something
# sensible is returned. Might need if we ever do a site for Time Lords!
(y2100, past, "Will start 2100, now ended"),
(y2100, y2000, "2100 → 2000"),
(future, past, "Ended"),
(future, y2000, "Ended 2000"),
(future, y2100, "Will end 2100"),
)
for start_date, end_date, expected in tests:
position.start_date = start_date
position.end_date = end_date
actual = position.display_dates()
self.assertEqual(
actual, expected, "%s -> %s should be '%s', not '%s'" %
(start_date, end_date, expected, actual))
def handle_noargs(self, **options):
pt = PositionTitle.objects.get(name='Constituency Contact')
for old_position in pt.position_set.all(). \
currently_active(date_for_last_active_check):
person = old_position.person
print "Considering", old_position
active_positions = person.position_set.all().currently_active()
# Are they currently an MP or an MPL?
na_memberships = active_positions.filter(
organisation__slug='national-assembly', title__slug='member')
# FIXME: Why are there two representations of MPLs?
pl_memberships = active_positions.filter(
title__slug='member',
organisation__kind__slug='provincial-legislature')
pl_memberships2 = active_positions.filter(
title__slug='member-of-the-provincial-legislature')
restart = False
if na_memberships:
print " Restarting because", person, "is currently a Member of the National Assembly"
restart = True
if pl_memberships or pl_memberships2:
print " Restarting because", person, "is currently a Member of a Provincial Legislature"
restart = True
if restart:
# Set the primary key to None so that when we save it,
# that creates a new row:
old_position.pk = None
old_position.start_date = ApproximateDate(
*date_to_start_new_positions.timetuple()[0:3])
old_position.end_date = ApproximateDate(future=True)
if options['commit']:
print " Saving the new position"
old_position.save()
else:
print " Not saving the new position (--commit not specified)"
def get_matching_party(party_name, **options):
party_name_to_use = party_name_corrections.get(party_name, party_name)
# print "looking for '%s'" % (party_name_to_use,)
matching_parties = Organisation.objects.filter(
kind__slug='party', name__iexact=party_name_to_use)
if not matching_parties:
matching_parties = Organisation.objects.filter(
kind__slug='party', name__istartswith=party_name_to_use)
if len(matching_parties) == 0:
if options.get('create', True):
party_name_for_creation = party_name_to_use.title()
new_party = Organisation(
name=party_name_for_creation,
slug=slugify(party_name_for_creation),
started=ApproximateDate(datetime.date.today().year),
ended=None,
kind=OrganisationKind.objects.get(slug='party'))
maybe_save(new_party, **options)
return new_party
else:
raise CommandError, "Would have to create %s, but 'create' was False" % (
party_name, )
elif len(matching_parties) == 1:
return matching_parties[0]
else:
raise Exception, "Multiple parties matched %s" % (party_name_to_use, )
def event(request, city):
now = timezone.now()
now_approx = ApproximateDate(year=now.year, month=now.month, day=now.day)
page = get_object_or_404(EventPage.objects.select_related('event'),
url=city.lower())
if page.url != city:
return redirect('core:event', city=page.url, permanent=True)
can_show = request.user.is_authenticated() or 'preview' in request.GET
if not page.is_live and not can_show:
return render(request, 'applications/event_not_live.html', {
'city': city,
'past': page.event.date <= now_approx
})
return render(
request, "core/event.html", {
'page':
page,
'menu':
page.menu.all(),
'content':
page.content.prefetch_related('coaches',
'sponsors').filter(is_public=True),
})
def event(request, page_url):
now = timezone.now()
now_approx = ApproximateDate(year=now.year, month=now.month, day=now.day)
event_obj = get_object_or_404(Event, page_url=page_url.lower())
user = request.user
user_is_organizer = user.is_authenticated and event_obj.has_organizer(user)
is_preview = 'preview' in request.GET
can_preview = user.is_superuser or user_is_organizer or is_preview
if event_obj.date:
is_past = event_obj.date <= now_approx
else:
is_past = False
if not (event_obj.is_page_live or can_preview) or event_obj.is_frozen:
return render(request, 'applications/event_not_live.html', {
'city': event_obj.city,
'page_url': page_url,
'past': is_past
})
return render(
request, "core/event.html", {
'event':
event_obj,
'menu':
event_obj.menu.all(),
'content':
event_obj.content.prefetch_related(
'coaches', 'sponsors').filter(is_public=True),
})
def tidy_date(date):
if not date:
return None
if date == 'future':
return ApproximateDate(future=True)
if re.match(r'^\d{4}$', date):
return ApproximateDate(year=int(date))
month_year = re.match(r'^(\d{2})-(\d{4})$', date)
if month_year:
month, year = month_year.groups()
return ApproximateDate(month=int(month), year=int(year))
print 'bad date: %s' % date