def test_parsing_tricky_dates(self):
"""Test if non-dates don't get parsed."""
tests = [
(('wrong start date', 'wrong end date'), (None, None)),
(('11/19/2015', '11/19/2015'), (None, None)),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (startdate, enddate), (start, end) in tests:
with self.subTest(dates=(startdate, enddate)):
metadata = dict(startdate=startdate, enddate=enddate)
expected['start'] = start
expected['end'] = end
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_country_language(self):
"""Ensure we always get a 2-char string or nothing."""
tests = [
(('Usa', 'English'), ('US', 'EN')),
(('U', 'E'), ('', '')),
(('', ''), ('', '')),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (country, language), (country_exp, language_exp) in tests:
with self.subTest(iso_31661=(country, language)):
metadata = dict(country=country, language=language)
expected['country'] = country_exp
expected['language'] = language_exp
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_new_latlng(self):
metadata = {
'slug': '2015-07-13-test',
'startdate': '2015-07-13',
'enddate': '2015-07-14',
'country': 'us',
'venue': 'Euphoric State University',
'address': 'Highway to Heaven 42, Academipolis',
'lat': '36.998977',
'lng': '-109.045173',
'language': 'us',
'instructor': 'Hermione Granger|Ron Weasley',
'helper': 'Peter Parker|Tony Stark|Natasha Romanova',
'contact': '[email protected], [email protected]',
'eventbrite': '10000000',
}
expected = {
'slug': '2015-07-13-test',
'language': 'US',
'start': datetime.date(2015, 7, 13),
'end': datetime.date(2015, 7, 14),
'country': 'US',
'venue': 'Euphoric State University',
'address': 'Highway to Heaven 42, Academipolis',
'latitude': 36.998977,
'longitude': -109.045173,
'reg_key': 10000000,
'instructors': ['Hermione Granger', 'Ron Weasley'],
'helpers': ['Peter Parker', 'Tony Stark', 'Natasha Romanova'],
'contact': '[email protected], [email protected]',
}
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_list_of_names(self):
"""Ensure we always get a list."""
tests = [
(('', ''), ([], [])),
(('Hermione Granger', 'Peter Parker'),
(['Hermione Granger'], ['Peter Parker'])),
(('Harry,Ron', 'Hermione,Ginny'),
(['Harry,Ron'], ['Hermione,Ginny'])),
(('Harry| Ron', 'Hermione |Ginny'),
(['Harry', 'Ron'], ['Hermione', 'Ginny'])),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected['instructors'] = instructors
expected['helpers'] = helpers
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_latitude_longitude(self):
tests = [
('XYZ', (None, None)),
('XYZ, ', (None, None)),
(',-123', (None, -123.0)),
(',', (None, None)),
(None, (None, None)),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for latlng, (latitude, longitude) in tests:
with self.subTest(latlng=latlng):
metadata = dict(latlng=latlng)
expected['latitude'] = latitude
expected['longitude'] = longitude
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_eventbrite_id(self):
tests = [
('', None),
('string', None),
(None, None),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for eventbrite_id, reg_key in tests:
with self.subTest(eventbrite_id=eventbrite_id):
metadata = dict(eventbrite=eventbrite_id)
expected['reg_key'] = reg_key
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_no_attribute_error_missing_instructors_helpers(self):
"""Regression test: ensure no exception is raised when instructors
or helpers aren't in the metadata or their values are None."""
tests = [
((None, None), ([], [])),
((None, ''), ([], [])),
(('', None), ([], [])),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected['instructors'] = instructors
expected['helpers'] = helpers
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_list_of_names(self):
"""Ensure we always get a list."""
tests = [
(('', ''), ([], [])),
(('Hermione Granger', 'Peter Parker'),
(['Hermione Granger'], ['Peter Parker'])),
(('Harry,Ron', 'Hermione,Ginny'),
(['Harry,Ron'], ['Hermione,Ginny'])),
(('Harry| Ron', 'Hermione |Ginny'),
(['Harry', 'Ron'], ['Hermione', 'Ginny'])),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected['instructors'] = instructors
expected['helpers'] = helpers
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_latitude_longitude(self):
tests = [
('XYZ', (None, None)),
('XYZ, ', (None, None)),
(',-123', (None, -123.0)),
(',', (None, None)),
(None, (None, None)),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for latlng, (latitude, longitude) in tests:
with self.subTest(latlng=latlng):
metadata = dict(latlng=latlng)
expected['latitude'] = latitude
expected['longitude'] = longitude
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_dates(self):
"""Test if non-dates don't get parsed."""
tests = [
(('wrong start date', 'wrong end date'), (None, None)),
(('11/19/2015', '11/19/2015'), (None, None)),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (startdate, enddate), (start, end) in tests:
with self.subTest(dates=(startdate, enddate)):
metadata = dict(startdate=startdate, enddate=enddate)
expected['start'] = start
expected['end'] = end
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_country_language(self):
"""Ensure we always get a 2-char string or nothing."""
tests = [
(('Usa', 'English'), ('US', 'EN')),
(('U', 'E'), ('', '')),
(('', ''), ('', '')),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (country, language), (country_exp, language_exp) in tests:
with self.subTest(iso_31661=(country, language)):
metadata = dict(country=country, language=language)
expected['country'] = country_exp
expected['language'] = language_exp
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_tricky_eventbrite_id(self):
tests = [
('', None),
('string', None),
(None, None),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for eventbrite_id, reg_key in tests:
with self.subTest(eventbrite_id=eventbrite_id):
metadata = dict(eventbrite=eventbrite_id)
expected['reg_key'] = reg_key
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_parsing_correct_metadata(self):
metadata = {
'slug': '2015-07-13-test',
'startdate': '2015-07-13',
'enddate': '2015-07-14',
'country': 'us',
'venue': 'Euphoric State University',
'address': 'Highway to Heaven 42, Academipolis',
'latlng': '36.998977, -109.045173',
'language': 'us',
'instructor': 'Hermione Granger|Ron Weasley',
'helper': 'Peter Parker|Tony Stark|Natasha Romanova',
'contact': '[email protected], [email protected]',
'eventbrite': '10000000',
}
expected = {
'slug': '2015-07-13-test',
'language': 'US',
'start': datetime.date(2015, 7, 13),
'end': datetime.date(2015, 7, 14),
'country': 'US',
'venue': 'Euphoric State University',
'address': 'Highway to Heaven 42, Academipolis',
'latitude': 36.998977,
'longitude': -109.045173,
'reg_key': 10000000,
'instructors': ['Hermione Granger', 'Ron Weasley'],
'helpers': ['Peter Parker', 'Tony Stark', 'Natasha Romanova'],
'contact': '[email protected], [email protected]',
}
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def test_no_attribute_error_missing_instructors_helpers(self):
"""Regression test: ensure no exception is raised when instructors
or helpers aren't in the metadata or their values are None."""
tests = [
((None, None), ([], [])),
((None, ''), ([], [])),
(('', None), ([], [])),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected['instructors'] = instructors
expected['helpers'] = helpers
self.assertEqual(expected, parse_metadata_from_event_website(metadata))
def workshoprequest_accept_event(request, request_id):
"""Accept event request by creating a new event."""
wr = get_object_or_404(WorkshopRequest, state='p', pk=request_id)
if request.method == 'POST':
form = EventCreateForm(request.POST)
if form.is_valid():
event = form.save()
wr.state = 'a'
wr.event = event
wr.save()
return redirect(reverse('event_details', args=[event.slug]))
else:
messages.error(request, 'Fix errors below.')
else:
# non-POST request
form = EventCreateForm()
# perhaps this WorkshopRequest has URL and we could pre-fill
# the form?
if wr.organization_type == 'self' and wr.self_organized_github:
try:
url = wr.self_organized_github.strip()
metadata = fetch_event_metadata(url)
data = parse_metadata_from_event_website(metadata)
if 'language' in data:
lang = data['language'].lower()
data['language'] = Language.objects.get(subtag=lang)
if 'instructors' in data or 'helpers' in data:
instructors = data.get('instructors') or ['none']
helpers = data.get('helpers') or ['none']
data['comment'] = "Instructors: {}\n\nHelpers: {}" \
.format(','.join(instructors), ','.join(helpers))
form = EventCreateForm(initial=data)
except (AttributeError, KeyError, ValueError, HTTPError,
RequestException, WrongWorkshopURL, Language.DoesNotExist):
# ignore errors
messages.warning(
request, "Cannot automatically fill the form "
"from provided workshop URL.")
context = {
'object': wr,
'form': form,
}
return render(request, 'requests/workshoprequest_accept_event.html',
context)
def workshoprequest_accept_event(request, request_id):
"""Accept event request by creating a new event."""
wr = get_object_or_404(WorkshopRequest, state='p', pk=request_id)
if request.method == 'POST':
form = EventCreateForm(request.POST)
if form.is_valid():
event = form.save()
wr.state = 'a'
wr.event = event
wr.save()
return redirect(reverse('event_details',
args=[event.slug]))
else:
messages.error(request, 'Fix errors below.')
else:
# non-POST request
form = EventCreateForm()
# perhaps this WorkshopRequest has URL and we could pre-fill
# the form?
if wr.organization_type == 'self' and wr.self_organized_github:
try:
url = wr.self_organized_github.strip()
metadata = fetch_event_metadata(url)
data = parse_metadata_from_event_website(metadata)
if 'language' in data:
lang = data['language'].lower()
data['language'] = Language.objects.get(subtag=lang)
if 'instructors' in data or 'helpers' in data:
instructors = data.get('instructors') or ['none']
helpers = data.get('helpers') or ['none']
data['comment'] = "Instructors: {}\n\nHelpers: {}" \
.format(','.join(instructors), ','.join(helpers))
form = EventCreateForm(initial=data)
except (AttributeError, KeyError, ValueError, HTTPError,
RequestException, WrongWorkshopURL, Language.DoesNotExist):
# ignore errors
messages.warning(request, "Cannot automatically fill the form "
"from provided workshop URL.")
context = {
'object': wr,
'form': form,
}
return render(request, 'requests/workshoprequest_accept_event.html',
context)
def test_parsing_empty_metadata(self):
empty_dict = {}
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
self.assertEqual(expected, parse_metadata_from_event_website(empty_dict))
def test_parsing_empty_metadata(self):
empty_dict = {}
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': '',
}
self.assertEqual(expected, parse_metadata_from_event_website(empty_dict))
def get_event_metadata(self, event_url):
"""Get metadata from event (location, instructors, helpers, etc.)."""
metadata = fetch_event_metadata(event_url)
# normalize the metadata
metadata = parse_metadata_from_event_website(metadata)
return metadata
def selforganisedsubmission_accept_event(request, submission_id):
"""Accept event request by creating a new event."""
wr = get_object_or_404(SelfOrganisedSubmission,
state='p',
pk=submission_id)
mix_match = wr.workshop_types.filter(mix_match=True).exists()
FormClass = partial(
EventCreateForm,
show_lessons=mix_match,
)
if request.method == 'POST':
form = FormClass(request.POST)
if form.is_valid():
event = form.save()
person = wr.host()
if person:
Task.objects.create(event=event,
person=person,
role=Role.objects.get(name="host"))
wr.state = 'a'
wr.event = event
wr.save()
return redirect(reverse('event_details', args=[event.slug]))
else:
messages.error(request, 'Fix errors below.')
else:
# non-POST request
form = FormClass()
try:
url = wr.workshop_url.strip()
metadata = fetch_event_metadata(url)
data = parse_metadata_from_event_website(metadata)
data.update({
'url':
url,
'curricula':
list(wr.workshop_types.all()),
'host':
wr.host_organization() or wr.institution,
'administrator':
Organization.objects.get(domain='self-organized'),
})
if mix_match:
data.update({
'tags': [Tag.objects.get(name='Circuits')],
})
if 'language' in data:
lang = data['language'].lower()
data['language'] = Language.objects.get(subtag=lang)
if 'instructors' in data or 'helpers' in data:
instructors = data.get('instructors') or ['none']
helpers = data.get('helpers') or ['none']
data['comment'] = "Instructors: {}\n\nHelpers: {}" \
.format(','.join(instructors), ','.join(helpers))
form = FormClass(initial=data)
except (AttributeError, KeyError, ValueError, HTTPError,
RequestException, WrongWorkshopURL, Language.DoesNotExist):
# ignore errors
messages.warning(
request, "Cannot automatically fill the form "
"from provided workshop URL.")
context = {
'object': wr,
'form': form,
}
return render(request,
'requests/selforganisedsubmission_accept_event.html',
context)
def empty_metadata(self):
"""Prepare basic, empty metadata."""
return parse_metadata_from_event_website({})
def get_event_metadata(self, event_url):
"""Get metadata from event (location, instructors, helpers, etc.)."""
metadata = fetch_event_metadata(event_url)
# normalize the metadata
metadata = parse_metadata_from_event_website(metadata)
return metadata
def empty_metadata(self):
"""Prepare basic, empty metadata."""
return parse_metadata_from_event_website({})
