def test_post_form_valid_make_new_allocation(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
allocations = volunteer_opp.resources_allocated.all()
volunteer = ProfileFactory()
url = reverse(
self.view_name,
args=[context.conference.conference_slug, volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
data = self.get_create_data()
data['worker'] = volunteer.pk,
login_as(self.privileged_profile, self)
response = self.client.post(url, data=data, follow=True)
alloc = volunteer_opp.resources_allocated.all().order_by(
'pk').reverse().first()
self.assertIsNotNone(alloc)
self.assert_good_post(response,
volunteer_opp,
volunteer,
alloc,
'Do these notes work?',
allocations=3)
assert len(volunteer.volunteering.all().filter(
b_conference=volunteer_opp.eventitem.get_conference())) == 1
def test_no_past_conference_details(self):
'''only current conference events, and windows should be shown'''
# horrible setup process. Need to fix
data = self.set_basic_opportunity()
past_context = StaffAreaContext(
conference=ConferenceFactory(
status='completed'))
past_opp = past_context.add_volunteer_opp()
past_opp.starttime = datetime(2015, 2, 25, 6, 0, 0, 0, pytz.utc)
past_opp.eventitem.max_volunteer = 10
past_opp.eventitem.save()
past_window = VolunteerWindowFactory(
day__conference=past_context.conference)
url = reverse(self.view_name,
args=[data['volunteer'].pk],
urlconf="gbe.urls")
login_as(self.privileged_user, self)
response = self.client.get(url)
nt.assert_not_in(
str(past_opp.eventitem),
response.content,
msg="Event Title for past_opportunity should not show up")
nt.assert_not_in(
date_format(past_opp.starttime, "SHORT_DATETIME_FORMAT"),
response.content,
msg="start time for past_sched shouldn't show up")
def test_no_past_conference_details(self):
'''only current conference events, and windows should be shown'''
# horrible setup process. Need to fix
data = self.set_basic_opportunity()
past_context = StaffAreaContext(conference=ConferenceFactory(
status='completed'))
past_opp = past_context.add_volunteer_opp()
past_opp.starttime = datetime(2015, 2, 25, 6, 0, 0, 0, pytz.utc)
past_opp.eventitem.max_volunteer = 10
past_opp.eventitem.save()
past_window = VolunteerWindowFactory(
day__conference=past_context.conference)
url = reverse(self.view_name,
args=[data['volunteer'].pk],
urlconf="gbe.urls")
login_as(self.privileged_user, self)
response = self.client.get(url)
nt.assert_not_in(
str(past_opp.eventitem),
response.content,
msg="Event Title for past_opportunity should not show up")
nt.assert_not_in(date_format(past_opp.starttime,
"SHORT_DATETIME_FORMAT"),
response.content,
msg="start time for past_sched shouldn't show up")
def test_authorized_user_pick_mode_only_children(self):
target_context = StaffAreaContext()
delta = timedelta(days=340)
target_day = ConferenceDayFactory(conference=target_context.conference,
day=self.context.conf_day.day +
delta)
new_room = target_context.get_room()
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'room': new_room.pk,
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(response,
self.copy_children_only_checked,
html=True)
self.assertContains(
response,
'<option value="%d" selected>' % (target_context.area.pk))
self.assertContains(response, "Choose Sub-Events to be copied")
self.assertContains(
response, "%s - %s" % (self.vol_opp.eventitem.e_title,
(self.vol_opp.start_time + delta).strftime(
self.copy_date_format)))
self.assert_hidden_value(response, "id_room", "room", new_room.pk)
def test_send_email_success_email_sent(self):
staffcontext = StaffAreaContext(conference=self.context.conference)
volunteer, booking = staffcontext.book_volunteer()
showcontext = ShowContext(conference=self.context.conference)
showcontext.set_producer(producer=staffcontext.staff_lead)
login_as(staffcontext.staff_lead, self)
data = {
'to': volunteer.user_object.email,
'sender': staffcontext.staff_lead.user_object.email,
'subject': "Subject",
'html_message': "<p>Test Message</p>",
'email-select-conference': [self.context.conference.pk],
'email-select-roles': ["Volunteer", ],
'event-select-events': showcontext.show.pk,
'event-select-staff_areas': staffcontext.area.pk,
'event-select-event_collections': "Volunteer",
'send': True
}
response = self.client.post(self.url, data=data, follow=True)
assert_queued_email(
[volunteer.user_object.email, ],
data['subject'],
data['html_message'],
data['sender'],
)
def test_post_form_valid_make_new_allocation_volunteer_exists(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
volunteer = VolunteerFactory(
submitted=False,
accepted=2,
b_conference=context.conference)
VolunteerInterestFactory(
volunteer=volunteer,
interest=volunteer_opp.as_subtype.volunteer_type)
url = reverse(self.view_name,
args=[context.conference.conference_slug,
volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
data = self.get_create_data()
data['worker'] = volunteer.profile.pk,
login_as(self.privileged_profile, self)
response = self.client.post(url, data=data, follow=True)
alloc = volunteer_opp.resources_allocated.all().order_by(
'pk').reverse().first()
self.assertIsNotNone(alloc)
self.assert_good_post(
response,
volunteer_opp,
volunteer.profile,
alloc,
'Do these notes work?',
allocations=3)
assert len(volunteer.profile.volunteering.all().filter(
b_conference=volunteer_opp.eventitem.get_conference())) == 1
updated = get_object_or_404(Volunteer, pk=volunteer.pk)
assert updated.submitted
assert updated.accepted == 3
def test_copy_child_event(self):
target_context = StaffAreaContext()
target_day = ConferenceDayFactory(conference=target_context.conference,
day=self.context.conf_day.day +
timedelta(days=340))
new_room = target_context.get_room()
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'copied_event': self.vol_opp.pk,
'room': new_room.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
max_pk = Event.objects.latest('pk').pk
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[target_context.conference.conference_slug]),
target_context.conference.conference_slug,
target_day.pk,
str([max_pk]),
)
self.assertRedirects(response, redirect_url)
self.assertContains(response, new_room)
def test_post_form_valid_make_new_allocation(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
allocations = volunteer_opp.resources_allocated.all()
volunteer = ProfileFactory()
url = reverse(self.view_name,
args=[context.conference.conference_slug,
volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
data = self.get_create_data()
data['worker'] = volunteer.pk,
login_as(self.privileged_profile, self)
response = self.client.post(url, data=data, follow=True)
alloc = volunteer_opp.resources_allocated.all().order_by(
'pk').reverse().first()
self.assertIsNotNone(alloc)
self.assert_good_post(
response,
volunteer_opp,
volunteer,
alloc,
'Do these notes work?',
allocations=3)
assert len(volunteer.volunteering.all().filter(
b_conference=volunteer_opp.eventitem.get_conference())) == 1
def test_send_email_success_email_sent(self):
staffcontext = StaffAreaContext(conference=self.context.conference)
volunteer, booking = staffcontext.book_volunteer()
showcontext = ShowContext(conference=self.context.conference)
showcontext.set_producer(producer=staffcontext.staff_lead)
login_as(staffcontext.staff_lead, self)
data = {
'to': volunteer.user_object.email,
'sender': staffcontext.staff_lead.user_object.email,
'subject': "Subject",
'html_message': "<p>Test Message</p>",
'email-select-conference': [self.context.conference.pk],
'email-select-roles': [
"Volunteer",
],
'event-select-events': showcontext.show.pk,
'event-select-staff_areas': staffcontext.area.pk,
'event-select-event_collections': "Volunteer",
'send': True
}
response = self.client.post(self.url, data=data, follow=True)
assert_queued_email(
[
volunteer.user_object.email,
],
data['subject'],
data['html_message'],
data['sender'],
)
def test_send_email_failure_preserve_choices(self):
staffcontext = StaffAreaContext(conference=self.context.conference)
volunteer, booking = staffcontext.book_volunteer()
showcontext = ShowContext(conference=self.context.conference)
showcontext.set_producer(producer=staffcontext.staff_lead)
login_as(self.privileged_profile, self)
data = {
'to': volunteer.user_object.email,
'sender': "*****@*****.**",
'html_message': "<p>Test Message</p>",
'email-select-conference': [self.context.conference.pk],
'email-select-roles': [
"Interested",
],
'event-select-events': showcontext.show.pk,
'event-select-staff_areas': staffcontext.area.pk,
'event-select-event_collections': "Volunteer",
'send': True
}
response = self.client.post(self.url, data=data, follow=True)
assert_checkbox(response, "conference", 0, self.context.conference.pk,
self.context.conference.conference_slug)
assert_checkbox(response, "roles", 0, "Interested", "Interested")
assert_checkbox(response,
"events",
0,
showcontext.show.pk,
showcontext.show.e_title,
prefix="event-select")
assert_checkbox(response,
"event_collections",
2,
"Volunteer",
"All Volunteer Events",
prefix="event-select")
def test_good_user_get_volunteer_w_teacher_as_persona(self):
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
staff_context = StaffAreaContext()
volunteer_sched_event = staff_context.add_volunteer_opp()
volunteer_sched_event.approval_needed = True
volunteer_sched_event.save()
teacher = PersonaFactory()
teacher, alloc = staff_context.book_volunteer(
volunteer_sched_event=volunteer_sched_event,
volunteer=teacher,
role="Teacher")
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[staff_context.conference.conference_slug,
volunteer_sched_event.pk])
response = self.client.get(url)
self.assertContains(
response,
'<input type="checkbox" name="approval" ' +
'id="id_approval" checked />',
html=True)
self.assertContains(
response,
'<option value="%d" selected>%s</option>' % (
staff_context.area.pk,
staff_context.area),
html=True)
def test_post_form_valid_make_new_allocation_volunteer_exists(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
volunteer = VolunteerFactory(submitted=False,
accepted=2,
b_conference=context.conference)
VolunteerInterestFactory(
volunteer=volunteer,
interest=volunteer_opp.as_subtype.volunteer_type)
url = reverse(
self.view_name,
args=[context.conference.conference_slug, volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
data = self.get_create_data()
data['worker'] = volunteer.profile.pk,
login_as(self.privileged_profile, self)
response = self.client.post(url, data=data, follow=True)
alloc = volunteer_opp.resources_allocated.all().order_by(
'pk').reverse().first()
self.assertIsNotNone(alloc)
self.assert_good_post(response,
volunteer_opp,
volunteer.profile,
alloc,
'Do these notes work?',
allocations=3)
assert len(volunteer.profile.volunteering.all().filter(
b_conference=volunteer_opp.eventitem.get_conference())) == 1
updated = get_object_or_404(Volunteer, pk=volunteer.pk)
assert updated.submitted
assert updated.accepted == 3
def test_get_staff_area(self):
staff_context = StaffAreaContext(conference=self.context.conference)
volunteer, booking = staff_context.book_volunteer(
role="Pending Volunteer")
login_as(self.privileged_user, self)
response = self.client.get(
self.url, {'conf_slug': self.context.conference.conference_slug})
self.assert_volunteer_state(response, booking)
self.assertContains(response, str(staff_context.area))
def setUp(self):
self.context = StaffAreaContext()
self.vol_opp = self.context.add_volunteer_opp()
self.url = reverse(self.view_name,
args=[self.context.area.pk],
urlconf='gbe.scheduling.urls')
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def setUp(self):
self.room = RoomFactory()
self.context = StaffAreaContext()
self.context.area.default_volunteers = 7
self.context.area.save()
self.url = reverse(self.view_name,
args=[self.context.area.pk],
urlconf='gbe.scheduling.urls')
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def test_no_available_volunteers(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
volunteer, alloc = context.book_volunteer(volunteer_opp)
login_as(self.privileged_profile, self)
response = self.client.get(reverse(
self.view_name,
args=[context.conference.conference_slug, volunteer_opp.pk],
urlconf="gbe.scheduling.urls"),
follow=True)
assert ("no available volunteers" in response.content)
def setUp(self):
self.client = Client()
self.profile = ProfileFactory()
self.context = StaffAreaContext()
self.volunteeropp = self.context.add_volunteer_opp()
self.url = reverse(self.view_name,
args=[self.volunteeropp.pk, "on"],
urlconf="gbe.scheduling.urls")
self.unsub_link = Site.objects.get_current().domain + reverse(
'email_update', urlconf='gbe.urls'
) + "?email_disable=send_schedule_change_notifications"
def setUp(self):
self.url = reverse('volunteer_signup', urlconf="gbe.scheduling.urls")
self.client = Client()
self.profile = ProfileFactory()
clear_conferences()
conference = ConferenceFactory()
save_the_date = datetime(2016, 2, 6, 12, 0, 0)
day = ConferenceDayFactory(conference=conference,
day=date(2016, 0o2, 0o6))
self.staffcontext = StaffAreaContext(conference=conference,
starttime=save_the_date)
self.volunteeropp = self.staffcontext.add_volunteer_opp()
def test_inactive_user_not_listed(self):
staff_context = StaffAreaContext()
volunteer_sched_event = staff_context.add_volunteer_opp()
inactive_persona = PersonaFactory(
contact__user_object__is_active=False)
login_as(self.privileged_user, self)
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[staff_context.conference.conference_slug,
volunteer_sched_event.pk])
response = self.client.get(url)
self.assertNotIn(str(inactive_persona), response.content)
self.assertNotIn(str(inactive_persona.contact), response.content)
def test_two_upcoming_conf(self):
second_conference = ConferenceFactory()
save_the_date = datetime(2017, 2, 6, 12, 0, 0)
second_day = ConferenceDayFactory(conference=second_conference,
day=date(2017, 0o2, 0o6))
staffcontext = StaffAreaContext(conference=second_conference,
starttime=save_the_date)
volunteeropp = staffcontext.add_volunteer_opp()
login_as(self.profile, self)
response = self.client.get(
"%s?conference=%s" % (self.url, second_conference.conference_slug))
self.assertContains(response, staffcontext.conference.conference_name)
self.assertContains(response, volunteeropp.eventitem.e_title)
def test_view_volunteers_waitlisted(self):
context = StaffAreaContext(conference=self.conf)
volunteer, booking = context.book_volunteer(role="Waitlisted")
opportunity = booking.event
opportunity.starttime = datetime.now() + timedelta(days=1)
opportunity.save()
login_as(volunteer, self)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=["Volunteer"])
response = self.client.get(
url, data={"conference": self.conf.conference_slug})
self.assertContains(response, opportunity.eventitem.e_title)
self.assertContains(response, "You were waitlisted for this shift.")
def test_no_available_volunteers(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
volunteer, alloc = context.book_volunteer(
volunteer_opp)
login_as(self.privileged_profile, self)
response = self.client.get(
reverse(
self.view_name,
args=[context.conference.conference_slug,
volunteer_opp.pk],
urlconf="gbe.scheduling.urls"),
follow=True)
assert ("no available volunteers" in response.content)
def setUp(self):
self.client = Client()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.url = reverse(self.view_name,
urlconf="gbe.scheduling.urls")
self.volunteer_context = VolunteerContext()
self.day = self.volunteer_context.conf_day
self.class_context = ClassContext(conference=self.day.conference)
self.show_context = ShowContext(conference=self.day.conference)
self.staff_context = StaffAreaContext(conference=self.day.conference)
booking, self.vol_opp = self.staff_context.book_volunteer()
def test_staff_area_with_inactive(self):
'''staff_area view should load
'''
context = StaffAreaContext()
inactive = ProfileFactory(display_name="DON'T SEE THIS",
user_object__is_active=False)
vol, opp = context.book_volunteer(volunteer=inactive)
grant_privilege(self.profile, 'Act Reviewers')
login_as(self.profile, self)
response = self.client.get("%s?area=Staff" % reverse(
'staff_area', urlconf="gbe.reporting.urls", args=[context.area.pk
]))
self.assertEqual(response.status_code, 200)
self.assertTrue('<tr style="color:red;">' in response.content)
def test_view_volunteers_past_event(self):
staff_context = StaffAreaContext(conference=self.conf)
opportunity = staff_context.add_volunteer_opp()
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=["Volunteer"])
response = self.client.get(
url, data={"conference": self.conf.conference_slug})
vol_link = reverse('set_volunteer',
args=[opportunity.pk, 'on'],
urlconf='gbe.scheduling.urls')
self.assertContains(response, opportunity.eventitem.e_title)
self.assertNotContains(response, vol_link)
self.assertNotContains(response, 'class="volunteer-icon"')
def test_authorized_user_get_set_staff_area(self):
staff = StaffAreaContext()
vol_sched_event = staff.add_volunteer_opp()
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[vol_sched_event.pk],
urlconf='gbe.scheduling.urls')
response = self.client.get(self.url)
self.assertContains(
response,
'<option value="%d" selected>%s</option>' % (
staff.area.pk,
staff.area.title),
html=True)
def test_good_user_get_volunteer_w_teacher_as_persona(self):
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
staff_context = StaffAreaContext()
volunteer_sched_event = staff_context.add_volunteer_opp()
teacher = PersonaFactory()
teacher, alloc = staff_context.book_volunteer(
volunteer_sched_event=volunteer_sched_event,
volunteer=teacher,
role="Teacher")
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[staff_context.conference.conference_slug,
volunteer_sched_event.pk])
response = self.client.get(url)
def test_pick_all_vol_reduced_priv(self):
staffcontext = StaffAreaContext()
volunteer, booking = staffcontext.book_volunteer()
special = GenericEventFactory(
e_conference=staffcontext.conference)
specialstaffcontext = VolunteerContext(
event=special,
)
login_as(staffcontext.staff_lead, self)
data = {
'email-select-conference': [staffcontext.conference.pk, ],
'email-select-roles': ['Volunteer', ],
'event-select-event_collections': "Volunteer",
'refine': True,
}
response = self.client.post(self.url, data=data, follow=True)
self.assertNotContains(
response,
self.context.teacher.contact.user_object.email)
self.assertContains(
response,
volunteer.user_object.email)
self.assertContains(
response,
specialstaffcontext.profile.user_object.email)
assert_checkbox(
response,
"events",
0,
special.pk,
special.e_title,
checked=False,
prefix="event-select")
assert_checkbox(
response,
"staff_areas",
0,
staffcontext.area.pk,
staffcontext.area.title,
checked=False,
prefix="event-select")
assert_checkbox(
response,
"event_collections",
0,
"Volunteer",
"All Volunteer Events",
prefix="event-select")
def test_copy_child_event(self):
target_context = StaffAreaContext()
target_day = ConferenceDayFactory(conference=target_context.conference,
day=self.context.conf_day.day +
timedelta(days=340))
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'copied_event': self.vol_opp.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
max_pk = Event.objects.latest('pk').pk
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[target_context.conference.conference_slug]),
target_context.conference.conference_slug,
target_day.pk,
str([max_pk]),
)
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response, 'success', 'Success',
'Occurrence has been updated.<br>%s, Start Time: %s' %
(self.vol_opp.eventitem.e_title,
datetime.combine(
target_day.day,
self.vol_opp.starttime.time()).strftime(DATETIME_FORMAT)))
def test_authorized_user_pick_mode_only_children(self):
target_context = StaffAreaContext()
delta = timedelta(days=340)
target_day = ConferenceDayFactory(conference=target_context.conference,
day=self.context.conf_day.day +
delta)
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(
response,
'<input checked="checked" id="id_copy_mode_0" name="copy_mode" ' +
'type="radio" value="copy_children_only" />')
self.assertContains(
response, '<option value="%d" selected="selected">' %
(target_context.area.pk))
self.assertContains(response, "Choose Sub-Events to be copied")
self.assertContains(
response, "%s - %s" % (self.vol_opp.eventitem.e_title,
(self.vol_opp.start_time + delta).strftime(
self.copy_date_format)))
def test_copy_area_duplicate_name(self):
dup_area_context = StaffAreaContext()
dup_area_context.area.title = self.context.area.title
dup_area_context.area.save()
conf_day = ConferenceDayFactory(conference=dup_area_context.conference)
self.url = reverse(self.view_name,
args=[dup_area_context.area.pk],
urlconf='gbe.scheduling.urls')
data = {
'copy_to_day': self.context.conf_day.pk,
'room': self.vol_opp.location.pk,
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug
]), self.context.conference.conference_slug,
self.context.conf_day.pk, str([dup_area_context.area.pk + 1]))
self.assertRedirects(response, redirect_url)
max_area = StaffArea.objects.latest('pk')
assert_alert_exists(
response, 'success', 'Success',
'A new Staff Area was created.<br>Staff Area: %s' %
(max_area.title))
def test_copy_only_area(self):
area_context = StaffAreaContext()
conf_day = ConferenceDayFactory(conference=area_context.conference)
another_day = ConferenceDayFactory()
another_room = RoomFactory()
another_room.conferences.add(another_day.conference)
data = {
'pick_mode': "Next",
'copy_to_day': another_day.pk,
'room': another_room.room.pk,
}
self.url = reverse(self.view_name,
args=[area_context.area.pk],
urlconf='gbe.scheduling.urls')
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[another_day.conference.conference_slug
]), another_day.conference.conference_slug,
another_day.pk, str([area_context.area.pk + 1]))
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response, 'success', 'Success',
'A new Staff Area was created.<br>Staff Area: %s' %
(area_context.area.title))
def test_create_opportunity_for_staff_area(self):
staff_context = StaffAreaContext(conference=self.context.conference)
self.url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[staff_context.area.pk])
grant_privilege(self.privileged_user, 'Scheduling Mavens')
login_as(self.privileged_profile, self)
response = self.client.post(self.url,
data=self.get_new_opp_data(self.context),
follow=True)
opps = Event.objects.filter(eventlabel__text=staff_context.area.slug)
self.assertTrue(opps.exists())
for opp in opps:
self.assertEqual(opp.eventitem.child().e_title,
'New Volunteer Opportunity')
self.assert_volunteer_type_selector(
response,
opp.eventitem.child().volunteer_type)
self.assertRedirects(
response, "%s?changed_id=%d&volunteer_open=True" %
(reverse('edit_staff',
urlconf='gbe.scheduling.urls',
args=[staff_context.area.pk]), opp.pk))
self.assertEqual(
EventLabel.objects.filter(
text=opp.eventitem.child().e_conference.conference_slug,
event=opp).count(), 1)
self.assertEqual(
EventLabel.objects.filter(text="Volunteer", event=opp).count(),
1)
self.assertContains(
response,
'<input id="id_e_title" maxlength="128" name="e_title" ' +
'type="text" value="New Volunteer Opportunity" />')
def test_copy_parent_w_area(self):
show_context = VolunteerContext()
staff = StaffAreaContext(conference=show_context.conference)
EventLabelFactory(event=show_context.sched_event, text=staff.area.slug)
url = reverse(
self.view_name,
args=[show_context.sched_event.pk],
urlconf='gbe.scheduling.urls')
data = {
'copy_mode': 'include_parent',
'copy_to_day': show_context.conf_day.pk,
'room': self.context.room.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(url, data=data, follow=True)
max_pk = Event.objects.latest('pk').pk
redirect_url = "%s?%s-day=%d&filter=Filter&new=[%s]" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[show_context.conference.conference_slug]),
show_context.conference.conference_slug,
show_context.conf_day.pk,
str(max_pk),)
self.assertContains(response, reverse(
'edit_staff',
urlconf='gbe.scheduling.urls',
args=[staff.area.pk]))
def test_past_staff_lead(self):
context = StaffAreaContext()
context.conference.status = "completed"
context.conference.save()
login_as(context.staff_lead, self)
response = self.client.get(self.url)
self.assertEqual(403, response.status_code)
def test_copy_single_set_area(self):
data, another_day, other_room = self.get_solo_data()
staff = StaffAreaContext(conference=another_day.conference)
data['copy_mode'] = ['copy_to_area', 'choose_day']
data['area'] = staff.area.pk
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[self.context.opp_event.pk],
urlconf='gbe.scheduling.urls')
response = self.client.post(self.url,
data=data,
follow=True)
max_pk = Event.objects.latest('pk').pk
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[another_day.conference.conference_slug]),
another_day.conference.conference_slug,
another_day.pk,
str([max_pk]),)
self.assertRedirects(response, redirect_url)
self.assertContains(response, other_room.name)
self.assertContains(response, reverse(
'edit_staff',
urlconf='gbe.scheduling.urls',
args=[staff.area.pk]))
def test_volunteer_changestate_gives_event_over_full_warning(self):
ProfilePreferencesFactory(profile=self.volunteer.profile)
context = StaffAreaContext(
conference=self.volunteer.b_conference,
)
opp = context.add_volunteer_opp()
context.book_volunteer(
volunteer_sched_event=opp,
volunteer=context.staff_lead)
url = reverse(self.view_name,
args=[self.volunteer.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
data = {'conference': self.volunteer.b_conference,
'events': [opp.pk],
'accepted': 3}
response = self.client.post(url, data=data, follow=True)
self.assertContains(response, "OCCURRENCE_OVERBOOKED")
def test_send_email_failure_preserve_choices(self):
staffcontext = StaffAreaContext(conference=self.context.conference)
volunteer, booking = staffcontext.book_volunteer()
showcontext = ShowContext(conference=self.context.conference)
showcontext.set_producer(producer=staffcontext.staff_lead)
login_as(self.privileged_profile, self)
data = {
'to': volunteer.user_object.email,
'sender': "*****@*****.**",
'html_message': "<p>Test Message</p>",
'email-select-conference': [self.context.conference.pk],
'email-select-roles': ["Interested", ],
'event-select-events': showcontext.show.pk,
'event-select-staff_areas': staffcontext.area.pk,
'event-select-event_collections': "Volunteer",
'send': True
}
response = self.client.post(self.url, data=data, follow=True)
assert_checkbox(
response,
"conference",
0,
self.context.conference.pk,
self.context.conference.conference_slug)
assert_checkbox(
response,
"roles",
0,
"Interested",
"Interested")
assert_checkbox(
response,
"events",
0,
showcontext.show.pk,
showcontext.show.e_title,
prefix="event-select")
assert_checkbox(
response,
"event_collections",
2,
"Volunteer",
"All Volunteer Events",
prefix="event-select")
def test_staff_area_with_inactive(self):
'''staff_area view should load
'''
context = StaffAreaContext()
inactive = ProfileFactory(
display_name="DON'T SEE THIS",
user_object__is_active=False
)
vol, opp = context.book_volunteer(volunteer=inactive)
grant_privilege(self.profile, 'Act Reviewers')
login_as(self.profile, self)
response = self.client.get(
"%s?area=Staff" %
reverse('staff_area',
urlconf="gbe.reporting.urls",
args=[context.area.pk]))
self.assertEqual(response.status_code, 200)
self.assertTrue(
'<tr style="color:red;">' in response.content)
def setUp(self):
self.context = StaffAreaContext()
self.vol_opp = self.context.add_volunteer_opp()
self.url = reverse(
self.view_name,
args=[self.context.area.pk],
urlconf='gbe.scheduling.urls')
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def test_send_email_success_status(self):
staffcontext = StaffAreaContext(conference=self.context.conference)
volunteer, booking = staffcontext.book_volunteer()
login_as(self.privileged_profile, self)
data = {
'to': volunteer.user_object.email,
'sender': self.privileged_profile.user_object.email,
'subject': "Subject",
'html_message': "<p>Test Message</p>",
'email-select-conference': [self.context.conference.pk],
'email-select-roles': ["Performer", "Volunteer"],
'event-select-staff_areas': staffcontext.area.pk,
'event-select-event_collections': "Volunteer",
'send': True
}
response = self.client.post(self.url, data=data, follow=True)
assert_alert_exists(
response, 'success', 'Success', "%s%s" % (
send_email_success_msg,
volunteer.user_object.email))
def setUp(self):
self.room = RoomFactory()
self.context = StaffAreaContext()
self.context.area.default_volunteers = 7
self.context.area.save()
self.url = reverse(
self.view_name,
args=[self.context.area.pk],
urlconf='gbe.scheduling.urls')
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def set_basic_opportunity(self):
context = StaffAreaContext()
current_sched = context.add_volunteer_opp()
current_sched.starttime = datetime(2016, 2, 5, 12, 0, 0, 0, pytz.utc)
current_sched.max_volunteer = 10
current_sched.save()
current_window = VolunteerWindowFactory(
day__conference=context.conference)
volunteer = VolunteerFactory(
b_conference=context.conference,
submitted=True)
volunteer.available_windows.add(current_window)
volunteer.save()
return {
'context': context,
'area': context.area,
'current_sched': current_sched,
'current_window': current_window,
'volunteer': volunteer
}
def setUp(self):
self.client = Client()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.context = StaffAreaContext()
self.volunteer_opp = self.context.add_volunteer_opp()
self.volunteer, self.alloc = self.context.book_volunteer(
self.volunteer_opp)
self.url = reverse(
self.view_name,
args=[self.context.conference.conference_slug,
self.volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
def setUp(self):
AvailableInterest.objects.all().delete()
self.client = Client()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.url = reverse(self.view_name,
urlconf="gbe.scheduling.urls")
self.volunteer_context = VolunteerContext()
self.day = self.volunteer_context.window.day
self.class_context = ClassContext(conference=self.day.conference)
self.another_interest = AvailableInterestFactory(interest="one more")
self.show_context = ShowContext(conference=self.day.conference)
self.staff_context = StaffAreaContext(conference=self.day.conference)
booking, self.vol_opp = self.staff_context.book_volunteer()
class TestEditStaffAreaView(TestCase):
'''This view edits classes that were made through the wizard'''
view_name = 'edit_staff'
def setUp(self):
self.room = RoomFactory()
self.context = StaffAreaContext()
self.context.area.default_volunteers = 7
self.context.area.save()
self.url = reverse(
self.view_name,
args=[self.context.area.pk],
urlconf='gbe.scheduling.urls')
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def edit_area(self):
data = {
'title': "Test Edit Staff",
'slug': "New_slug",
'conference': self.context.conference.pk,
'description': 'Description',
'default_volunteers': 3,
'location': self.room.pk,
'staff_lead': self.privileged_user.profile.pk,
'edit_event': "Save and Return",
}
return data
def test_edit_unauthorized_user(self):
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertEqual(403, response.status_code)
def test_authorized_user_can_access(self):
login_as(self.privileged_user, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "Volunteer Management")
self.assertContains(response, "Edit Staff Area Details")
self.assertContains(response, self.context.area.title)
self.assertContains(response, self.context.area.description)
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.context.staff_lead.profile.pk,
str(self.context.staff_lead.profile)))
self.assertContains(
response,
'name="default_volunteers" type="number" value="7"')
def test_authorized_user_can_get_volunteer_mgmt(self):
self.context.area.default_location = self.room
self.context.area.save()
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Volunteer Management")
self.assertContains(response, "Save and Continue")
self.assertContains(
response,
'name="new_opp-max_volunteer" type="number" value="7" />')
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.room.pk,
str(self.room)), 2)
def test_vol_opp_present(self):
self.context.area.default_room = self.room
self.context.area.save()
vol_opp = self.context.add_volunteer_opp()
self.extra_day = ConferenceDayFactory(
conference=self.context.conference,
day=self.context.conf_day.day + timedelta(days=1))
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
response = self.client.get(self.url, follow=True)
self.assertContains(
response,
'name="opp_event_id" type="hidden" value="%d" />' % (
vol_opp.eventitem.event_id)
)
self.assertContains(
response,
'name="opp_sched_id" type="hidden" value="%d" />' % (
vol_opp.pk)
)
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.context.conf_day.pk,
self.context.conf_day.day.strftime("%b. %-d, %Y")))
self.assertContains(
response,
'name="max_volunteer" type="number" value="7" />')
def test_bad_staff_area(self):
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[self.context.area.pk+1000],
urlconf='gbe.scheduling.urls')
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, 404)
def test_edit_area(self):
login_as(self.privileged_user, self)
response = self.client.post(
self.url,
data=self.edit_area(),
follow=True)
self.assertRedirects(
response,
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug]))
assert_alert_exists(
response,
'success',
'Success',
'Staff Area has been updated.<br>Title: Test Edit Staff')
def test_edit_area_and_continue(self):
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
data = self.edit_area()
data['edit_event'] = "Save and Continue"
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertRedirects(
response,
"%s?volunteer_open=True" % self.url)
assert_alert_exists(
response,
'success',
'Success',
'Staff Area has been updated.<br>Title: %s' % (
data['title']))
self.assertContains(response, data['title'])
self.assertContains(response, data['description'])
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.privileged_user.profile.pk,
str(self.privileged_user.profile)))
self.assertContains(
response,
'name="default_volunteers" type="number" value="3" />')
def test_auth_user_bad_user_assign(self):
login_as(self.privileged_user, self)
data = self.edit_area()
data['staff_lead'] = "bad role"
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
"That choice is not one of the available choices.")
class TestCopyOccurrence(TestCase):
view_name = 'copy_staff_schedule'
copy_date_format = "%a, %b %-d, %Y %-I:%M %p"
def setUp(self):
self.context = StaffAreaContext()
self.vol_opp = self.context.add_volunteer_opp()
self.url = reverse(
self.view_name,
args=[self.context.area.pk],
urlconf='gbe.scheduling.urls')
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def assert_good_mode_form(self, response, title):
self.assertEqual(response.status_code, 200)
self.assertContains(response,
self.context.conf_day.day.strftime(DATE_FORMAT))
self.assertContains(response, copy_mode_choices[0][1])
self.assertContains(response, copy_mode_choices[1][1])
def test_create_event_unauthorized_user(self):
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertEqual(403, response.status_code)
def test_authorized_user_can_access(self):
login_as(self.privileged_user, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Copying - %s" % self.context.area.title)
def test_bad_area(self):
url = reverse(
self.view_name,
args=[self.context.area.pk+100],
urlconf='gbe.scheduling.urls')
login_as(self.privileged_user, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def test_authorized_user_get_no_conf_days(self):
alt_context = StaffAreaContext()
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[alt_context.area.pk],
urlconf='gbe.scheduling.urls')
response = self.client.get(self.url, follow=True)
self.assertRedirects(response, reverse(
'manage_event_list',
urlconf='gbe.scheduling.urls',
args=[alt_context.conference.conference_slug]))
assert_alert_exists(
response,
'danger',
'Error',
no_conf_day_msg)
def test_authorized_user_get_no_children(self):
alt_context = StaffAreaContext()
ConferenceDayFactory(conference=alt_context.conference)
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[alt_context.area.pk],
urlconf='gbe.scheduling.urls')
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertContains(response,
self.context.conf_day.day.strftime(DATE_FORMAT))
self.assertNotContains(response, copy_mode_choices[0][1])
def test_authorized_user_get_w_child_events(self):
login_as(self.privileged_user, self)
response = self.client.get(self.url)
self.assert_good_mode_form(
response,
self.context.area.title)
def test_authorized_user_pick_mode_only_children(self):
target_context = StaffAreaContext()
delta = timedelta(days=340)
target_day = ConferenceDayFactory(
conference=target_context.conference,
day=self.context.conf_day.day + delta)
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(
response,
'<input checked="checked" id="id_copy_mode_0" name="copy_mode" ' +
'type="radio" value="copy_children_only" />')
self.assertContains(
response,
'<option value="%d" selected="selected">' % (
target_context.area.pk))
self.assertContains(response, "Choose Sub-Events to be copied")
self.assertContains(response, "%s - %s" % (
self.vol_opp.eventitem.e_title,
(self.vol_opp.start_time + delta).strftime(
self.copy_date_format)))
def test_authorized_user_pick_mode_children_same_conf(self):
target_context = StaffAreaContext(conference=self.context.conference)
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(
response,
'<input checked="checked" id="id_copy_mode_0" name="copy_mode" ' +
'type="radio" value="copy_children_only" />')
self.assertContains(
response,
'<option value="%d" selected="selected">' % (
target_context.area.pk))
self.assertContains(response, "Choose Sub-Events to be copied")
self.assertContains(response, "%s - %s" % (
self.vol_opp.eventitem.e_title,
self.vol_opp.start_time.strftime(self.copy_date_format)))
def test_copy_child_event(self):
target_context = StaffAreaContext()
target_day = ConferenceDayFactory(
conference=target_context.conference,
day=self.context.conf_day.day + timedelta(days=340))
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'copied_event': self.vol_opp.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
max_pk = Event.objects.latest('pk').pk
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[target_context.conference.conference_slug]),
target_context.conference.conference_slug,
target_day.pk,
str([max_pk]),)
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s' % (
self.vol_opp.eventitem.e_title,
datetime.combine(
target_day.day,
self.vol_opp.starttime.time()).strftime(
DATETIME_FORMAT)))
def test_copy_child_parent_events(self):
another_day = ConferenceDayFactory()
data = {
'copy_mode': 'include_parent',
'copy_to_day': another_day.pk,
'copied_event': self.vol_opp.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
max_pk = Event.objects.latest('pk').pk
response = self.client.post(self.url, data=data, follow=True)
new_occurrences = []
for occurrence in Event.objects.filter(pk__gt=max_pk):
new_occurrences += [occurrence.pk]
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s&alt_id=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[another_day.conference.conference_slug]),
another_day.conference.conference_slug,
another_day.pk,
replace(str(new_occurrences), " ", "%20"),
self.context.area.pk+1)
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response,
'success',
'Success',
'A new Staff Area was created.<br>Staff Area: %s' % (
self.context.area.title))
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s' % (
self.vol_opp.eventitem.e_title,
datetime.combine(
another_day.day,
self.vol_opp.starttime.time()).strftime(
DATETIME_FORMAT)))
def test_copy_child_parent_events_same_conf(self):
data = {
'copy_mode': 'include_parent',
'copy_to_day': self.context.conf_day.pk,
'copied_event': self.vol_opp.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
max_pk = Event.objects.latest('pk').pk
response = self.client.post(self.url, data=data, follow=True)
new_occurrences = []
max_area = StaffArea.objects.latest('pk')
for occurrence in Event.objects.filter(pk__gt=max_pk):
new_occurrences += [occurrence.pk]
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s&alt_id=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug]),
self.context.conference.conference_slug,
self.context.conf_day.pk,
replace(str(new_occurrences), " ", "%20"),
max_area.pk)
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response,
'success',
'Success',
'A new Staff Area was created.<br>Staff Area: %s' % (
max_area.title))
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s' % (
self.vol_opp.eventitem.e_title,
datetime.combine(
self.context.conf_day.day,
self.vol_opp.starttime.time()).strftime(
DATETIME_FORMAT)))
def test_copy_only_parent_event(self):
another_day = ConferenceDayFactory()
data = {
'copy_mode': 'include_parent',
'copy_to_day': another_day.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
max_area = StaffArea.objects.latest('pk')
redirect_url = "%s?%s-day=%d&filter=Filter&alt_id=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[another_day.conference.conference_slug]),
another_day.conference.conference_slug,
another_day.pk,
max_area.pk,)
self.assertRedirects(response, redirect_url)
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response,
'success',
'Success',
'A new Staff Area was created.<br>Staff Area: %s' % (
max_area.title))
def test_copy_child_event_fail_no_conf(self):
target_context = StaffAreaContext()
self.url = reverse(
self.view_name,
args=[target_context.area.pk],
urlconf='gbe.scheduling.urls')
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'copied_event': self.vol_opp.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertRedirects(response, reverse(
'manage_event_list',
urlconf='gbe.scheduling.urls',
args=[target_context.conference.conference_slug]))
assert_alert_exists(
response,
'danger',
'Error',
no_conf_day_msg)
class TestEventList(TestCase):
view_name = 'manage_event_list'
def setUp(self):
AvailableInterest.objects.all().delete()
self.client = Client()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.url = reverse(self.view_name,
urlconf="gbe.scheduling.urls")
self.volunteer_context = VolunteerContext()
self.day = self.volunteer_context.window.day
self.class_context = ClassContext(conference=self.day.conference)
self.another_interest = AvailableInterestFactory(interest="one more")
self.show_context = ShowContext(conference=self.day.conference)
self.staff_context = StaffAreaContext(conference=self.day.conference)
booking, self.vol_opp = self.staff_context.book_volunteer()
def assert_visible_input_selected(
self,
response,
conf_slug,
input_field,
input_index,
value,
checked=True):
if checked:
checked = 'checked="checked" '
else:
checked = ''
template_input = '<input %sid="id_%s-%s_%d" name="%s-%s" ' + \
'type="checkbox" value="%d" />'
assert_string = template_input % (
checked,
conf_slug,
input_field,
input_index,
conf_slug,
input_field,
value)
self.assertContains(response, assert_string)
def assert_hidden_input_selected(
self,
response,
conf_slug,
input_field,
input_index,
value,
exists=True):
template_input = '<input id="id_%s-%s_%d" name="%s-%s" ' + \
'type="hidden" value="%d" />'
assert_string = template_input % (
conf_slug,
input_field,
input_index,
conf_slug,
input_field,
value)
if exists:
self.assertContains(response, assert_string)
else:
self.assertNotContains(response, assert_string)
def test_no_login_gives_error(self):
response = self.client.get(self.url)
self.assertEqual(response.status_code, 302)
def test_bad_user(self):
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 403)
def test_good_user_get_success(self):
old_conf_day = ConferenceDayFactory(
conference__status="completed",
day=self.day.day + timedelta(3))
login_as(self.privileged_profile, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
s = '<li role="presentation" class="active">\n' + \
' <a href = "%s?">%s</a></li>'
self.assertContains(
response,
s % (reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[self.day.conference.conference_slug]),
self.day.conference.conference_slug))
s = '<li role="presentation" >\n <a href = "%s?">%s</a></li>'
self.assertContains(
response,
s % (reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[old_conf_day.conference.conference_slug]),
old_conf_day.conference.conference_slug))
self.assertContains(
response,
self.day.day.strftime(DATE_FORMAT))
self.assertNotContains(
response,
old_conf_day.day.strftime(DATE_FORMAT))
def test_good_user_get_interests(self):
old_interest = AvailableInterestFactory(
visible=False,
interest="old interest")
login_as(self.privileged_profile, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
self.another_interest.interest)
self.assertNotContains(
response,
old_interest.interest)
def test_good_user_get_staff_area(self):
other_staff_context = StaffAreaContext()
login_as(self.privileged_profile, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
self.staff_context.area.title)
self.assertNotContains(
response,
other_staff_context.area.title)
def test_good_user_get_create_edit(self):
login_as(self.privileged_profile, self)
data = {
"%s-calendar_type" % self.day.conference.conference_slug: [
0, 1, 2],
"filter": "Filter",
}
response = self.client.get(self.url, data)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
'<i class="fa fa-pencil" aria-hidden="true">')
def test_good_user_get_success_pick_conf(self):
old_conf_day = ConferenceDayFactory(
conference__status="completed",
day=self.day.day + timedelta(3))
login_as(self.privileged_profile, self)
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[old_conf_day.conference.conference_slug])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
s = '<li role="presentation" class="active">\n' + \
' <a href = "%s?">%s</a></li>'
self.assertContains(
response,
s % (url,
old_conf_day.conference.conference_slug))
s = '<li role="presentation" >\n <a href = "%s?">%s</a></li>'
self.assertContains(
response,
s % (reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[self.day.conference.conference_slug]),
self.day.conference.conference_slug))
self.assertContains(
response,
old_conf_day.day.strftime(DATE_FORMAT))
self.assertNotContains(
response,
self.day.day.strftime(DATE_FORMAT))
def test_good_user_get_no_create_edit(self):
old_conf_day = ConferenceDayFactory(
conference__status="completed",
day=self.day.day + timedelta(3))
context = ClassContext(conference=old_conf_day.conference)
data = {
"%s-calendar_type" % old_conf_day.conference.conference_slug: [
0, 1, 2],
"filter": "Filter",
}
login_as(self.privileged_profile, self)
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[old_conf_day.conference.conference_slug])
response = self.client.get(url, data)
self.assertContains(
response,
'<i class="fa fa-trash-o" aria-hidden="true">')
self.assertNotContains(
response,
'<i class="fa fa-pencil" aria-hidden="true">')
self.assertNotContains(
response,
'<i class="fa fa-plus" aria-hidden="true">')
def test_good_user_get_conference_cal(self):
login_as(self.privileged_profile, self)
data = {
"%s-calendar_type" % self.day.conference.conference_slug: 1,
"filter": "Filter",
}
response = self.client.get(self.url, data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.class_context.bid.e_title)
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"calendar_type",
1,
1)
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"calendar_type",
0,
0,
checked=False)
def test_good_user_get_conference_bad_filter(self):
login_as(self.privileged_profile, self)
data = {
"%s-calendar_type" % self.day.conference.conference_slug: "bad",
"filter": "Filter",
}
response = self.client.get(self.url, data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
"Select a valid choice. bad is not one of the available choices.")
def test_good_user_get_all_cals(self):
login_as(self.privileged_profile, self)
data = {
"%s-calendar_type" % self.day.conference.conference_slug: [
0, 1, 2],
"filter": "Filter",
}
response = self.client.get(self.url, data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.class_context.bid.e_title)
self.assertContains(response, self.show_context.show.e_title)
self.assertContains(response, self.vol_opp.event.eventitem.e_title)
self.assertContains(response, '<td class="bid-table">Volunteer</td>')
for value in range(0, 2):
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"calendar_type",
1,
1)
def test_good_user_get_day(self):
login_as(self.privileged_profile, self)
data = {
"%s-day" % self.day.conference.conference_slug: self.day.pk,
"filter": "Filter",
}
response = self.client.get(self.url, data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.show_context.show.e_title)
self.assertContains(response, self.class_context.bid.e_title)
counter = 0
for day in self.day.conference.conferenceday_set.all().order_by('day'):
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"day",
counter,
day.pk,
checked=(day == self.day))
counter += 1
for value in range(0, 2):
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"calendar_type",
1,
1,
checked=False)
def test_good_user_get_empty_day(self):
new_day = ConferenceDayFactory(conference=self.day.conference,
day=self.day.day+timedelta(14))
login_as(self.privileged_profile, self)
data = {
"%s-day" % self.day.conference.conference_slug: new_day.pk,
"filter": "Filter",
}
response = self.client.get(self.url, data=data)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, self.show_context.show.e_title)
self.assertNotContains(response, self.class_context.bid.e_title)
counter = 0
for day in self.day.conference.conferenceday_set.all().order_by('day'):
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"day",
counter,
day.pk,
checked=(day == new_day))
counter += 1
def test_good_user_get_volunteer_type(self):
login_as(self.privileged_profile, self)
data = {
"%s-volunteer_type" % self.day.conference.conference_slug:
self.volunteer_context.interest.interest.pk,
"filter": "Filter",
}
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[self.volunteer_context.conference.conference_slug])
response = self.client.get(url, data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response,
self.volunteer_context.opportunity.e_title)
self.assertNotContains(response, self.show_context.show.e_title)
self.assertNotContains(response, self.class_context.bid.e_title)
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"volunteer_type",
2,
self.volunteer_context.interest.interest.pk)
def test_good_user_get_bad_volunteer_type(self):
login_as(self.privileged_profile, self)
data = {
"%s-volunteer_type" % self.day.conference.conference_slug:
"bad",
"filter": "Filter",
}
response = self.client.get(self.url, data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
'"bad" is not a valid value for a primary key')
def test_good_user_filter_staff_area(self):
other_staff_area = StaffAreaContext(
conference=self.day.conference
)
login_as(self.privileged_profile, self)
data = {
"%s-staff_area" % self.day.conference.conference_slug: (
self.staff_context.area.pk),
"filter": "Filter",
}
response = self.client.get(self.url, data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.vol_opp.event.eventitem.e_title)
index = 0
for area in StaffArea.objects.filter(
conference=self.day.conference).order_by('title'):
self.assert_visible_input_selected(
response,
self.day.conference.conference_slug,
"staff_area",
index,
area.pk,
checked=(area == self.staff_context.area))
index += 1
def test_switch_conf_keep_filter(self):
old_conf_day = ConferenceDayFactory(
conference__status="completed",
day=self.day.day + timedelta(3))
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[old_conf_day.conference.conference_slug])
login_as(self.privileged_profile, self)
data = {
"%s-day" % self.day.conference.conference_slug: self.day.pk,
"%s-calendar_type" % self.day.conference.conference_slug: 1,
"%s-day" % old_conf_day.conference.conference_slug: (
old_conf_day.pk),
"%s-calendar_type" % old_conf_day.conference.conference_slug: 0,
"%s-staff_area" % self.day.conference.conference_slug: (
self.staff_context.area.pk),
"filter": "Filter",
}
response = self.client.get(url, data=data)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, self.show_context.show.e_title)
self.assertNotContains(response, self.class_context.bid.e_title)
for day in self.day.conference.conferenceday_set.all().order_by('day'):
self.assert_hidden_input_selected(
response,
self.day.conference.conference_slug,
"day",
0,
day.pk,
exists=(day == self.day))
self.assert_hidden_input_selected(
response,
self.day.conference.conference_slug,
"calendar_type",
0,
1)
self.assert_hidden_input_selected(
response,
self.day.conference.conference_slug,
"calendar_type",
0,
0,
False)
self.assert_hidden_input_selected(
response,
self.day.conference.conference_slug,
"staff_area",
0,
self.staff_context.area.pk)
class TestManageWorker(TestCase):
view_name = "manage_workers"
def setUp(self):
self.client = Client()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.context = StaffAreaContext()
self.volunteer_opp = self.context.add_volunteer_opp()
self.volunteer, self.alloc = self.context.book_volunteer(
self.volunteer_opp)
self.url = reverse(
self.view_name,
args=[self.context.conference.conference_slug,
self.volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
def get_edit_data(self):
data = self.get_either_data()
data['alloc_id'] = self.alloc.pk
return data
def get_create_data(self):
data = self.get_either_data()
data['alloc_id'] = -1
return data
def get_either_data(self):
data = {'worker': self.volunteer.pk,
'role': 'Volunteer',
'label': 'Do these notes work?'}
return data
def assert_post_contents(self,
response,
volunteer_opp,
volunteer,
alloc,
notes,
role="Volunteer",
allocations=2):
if volunteer == -1:
self.assertContains(
response,
'<option value="" selected="selected">---------</option>')
else:
self.assertContains(
response,
'<option value="' + str(volunteer.pk) +
'" selected="selected">' + str(volunteer) + '</option>')
self.assertContains(
response,
'<option value="' + role +
'" selected="selected">' + role +
'</option>')
self.assertContains(
response,
'<input id="id_alloc_id" name="alloc_id" type="hidden" value="' +
str(alloc.pk) + '" />')
self.assertContains(
response,
'<input id="id_label" maxlength="100" name="label" type="text" ' +
'value="' + notes + '" />')
self.assertContains(
response,
'<form method="POST" action="%s' % (reverse(
'manage_workers',
urlconf='gbe.scheduling.urls',
args=[volunteer_opp.eventitem.e_conference.conference_slug,
volunteer_opp.pk])))
def assert_good_post(self,
response,
volunteer_opp,
volunteer,
alloc,
notes,
role="Volunteer",
allocations=2):
self.assertRedirects(
response,
"%s?worker_open=True&changed_id=%d" % (
reverse(
'edit_volunteer',
urlconf='gbe.scheduling.urls',
args=[volunteer_opp.eventitem.e_conference.conference_slug,
volunteer_opp.pk]),
alloc.pk))
self.assert_post_contents(response,
volunteer_opp,
volunteer,
alloc,
notes,
role,
allocations,)
self.assertNotContains(response, '<ul class="errorlist">')
def test_no_login_gives_error(self):
response = self.client.get(self.url, follow=True)
redirect_url = reverse(
'login',
urlconf='gbe.urls') + "/?next=" + self.url
self.assertRedirects(response, redirect_url)
self.assertTrue(is_login_page(response))
def test_bad_user(self):
login_as(ProfileFactory(), self)
response = self.client.post(self.url, data=self.get_create_data())
self.assertEqual(response.status_code, 403)
def test_post_form_valid_make_new_allocation(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
allocations = volunteer_opp.resources_allocated.all()
volunteer = ProfileFactory()
url = reverse(self.view_name,
args=[context.conference.conference_slug,
volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
data = self.get_create_data()
data['worker'] = volunteer.pk,
login_as(self.privileged_profile, self)
response = self.client.post(url, data=data, follow=True)
alloc = volunteer_opp.resources_allocated.all().order_by(
'pk').reverse().first()
self.assertIsNotNone(alloc)
self.assert_good_post(
response,
volunteer_opp,
volunteer,
alloc,
'Do these notes work?',
allocations=3)
assert len(volunteer.volunteering.all().filter(
b_conference=volunteer_opp.eventitem.get_conference())) == 1
def test_post_form_valid_make_new_allocation_volunteer_exists(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
volunteer = VolunteerFactory(
submitted=False,
accepted=2,
b_conference=context.conference)
VolunteerInterestFactory(
volunteer=volunteer,
interest=volunteer_opp.as_subtype.volunteer_type)
url = reverse(self.view_name,
args=[context.conference.conference_slug,
volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
data = self.get_create_data()
data['worker'] = volunteer.profile.pk,
login_as(self.privileged_profile, self)
response = self.client.post(url, data=data, follow=True)
alloc = volunteer_opp.resources_allocated.all().order_by(
'pk').reverse().first()
self.assertIsNotNone(alloc)
self.assert_good_post(
response,
volunteer_opp,
volunteer.profile,
alloc,
'Do these notes work?',
allocations=3)
assert len(volunteer.profile.volunteering.all().filter(
b_conference=volunteer_opp.eventitem.get_conference())) == 1
updated = get_object_or_404(Volunteer, pk=volunteer.pk)
assert updated.submitted
assert updated.accepted == 3
def test_post_form_edit_exiting_allocation(self):
new_volunteer = ProfileFactory()
data = self.get_edit_data()
data['worker'] = new_volunteer.pk,
data['role'] = 'Producer',
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assert_good_post(
response,
self.volunteer_opp,
new_volunteer,
self.alloc,
'Do these notes work?',
"Producer")
def test_post_form_edit_bad_label(self):
big_label = 'Do these notes work?Do these notes work?' + \
'Do these notes work?Do these notes work?' + \
'Do these notes work?Do these notes work?' + \
'Do these notes work?Do these notes work?'
data = self.get_edit_data()
data['label'] = big_label
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
self.assert_post_contents(
response,
self.volunteer_opp,
self.volunteer,
self.alloc,
big_label)
self.assertContains(
response,
'<li>Ensure this value has at most 100 characters ' +
'(it has ' + str(len(big_label)) + ').</li>')
def test_post_form_edit_bad_role(self):
data = self.get_edit_data()
data['role'] = ''
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
self.assert_post_contents(
response,
self.volunteer_opp,
self.volunteer,
self.alloc,
'Do these notes work?')
self.assertContains(
response,
'<li>This field is required.</li>')
def test_post_form_edit_bad_role_and_booking(self):
data = self.get_edit_data()
data['role'] = ''
data['alloc_id'] = self.alloc.pk + 100
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
assert_alert_exists(
response,
'danger',
'Error',
'BOOKING_NOT_FOUND Booking id %s for occurrence %d not found' % (
self.alloc.pk + 100,
self.volunteer_opp.pk))
def test_post_form_create_bad_role(self):
data = self.get_create_data()
data['role'] = '',
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
self.assert_post_contents(
response,
self.volunteer_opp,
self.volunteer,
self.alloc,
'Do these notes work?')
self.assertContains(
response,
'<li>This field is required.</li>')
self.assertContains(
response,
'<a href="#" data-toggle="tooltip" title="Delete">',
count=1)
self.assertContains(
response,
'<a href="#" data-toggle="tooltip" title="Edit">',
count=1)
self.assertContains(
response,
'<a href="#" data-toggle="tooltip" title="Create New">',
count=1)
def test_post_form_valid_delete_allocation(self):
data = self.get_edit_data()
data['delete'] = 1
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertRedirects(
response,
"%s?worker_open=True&changed_id=%d" % (
reverse('edit_volunteer',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug,
self.volunteer_opp.pk]),
self.alloc.pk))
self.assertNotContains(
response,
'<option value="' + str(self.volunteer.pk) +
'" selected="selected">' + str(self.volunteer) + '</option>')
self.assertNotContains(
response,
'<input id="id_alloc_id" name="alloc_id" type="hidden" value="' +
str(self.alloc.pk) + '" />')
self.assertContains(
response,
'<form method="POST" action="%s' % (reverse(
self.view_name,
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug,
self.volunteer_opp.pk])))
def test_post_form_valid_delete_allocation_sends_notification(self):
data = self.get_edit_data()
data['delete'] = 1
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertRedirects(
response,
"%s?worker_open=True&changed_id=%d" % (
reverse('edit_volunteer',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug,
self.volunteer_opp.pk]),
self.alloc.pk))
msg = assert_email_template_used(
"A change has been made to your Volunteer Schedule!")
assert("http://%s%s" % (
Site.objects.get_current().domain,
reverse('home', urlconf='gbe.urls')) in msg.body)
def test_post_form_valid_notification_template_fail(self):
EmailTemplateSenderFactory(
from_email="*****@*****.**",
template__name='volunteer schedule update',
template__subject="test template",
template__content="stuff {% url 'gbehome' %} more stuff"
)
data = self.get_edit_data()
data['delete'] = 1
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertRedirects(
response,
"%s?worker_open=True&changed_id=%d" % (
reverse('edit_volunteer',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug,
self.volunteer_opp.pk]),
self.alloc.pk))
self.assertContains(response,
volunteer_allocate_email_fail_msg)
def test_post_form_valid_delete_allocation_w_bad_data(self):
data = self.get_edit_data()
data['role'] = ''
data['delete'] = 1
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(
response,
'This field is required.')
def test_post_form_valid_delete_allocation_w_no_alloc(self):
data = self.get_edit_data()
data['alloc_id'] = ''
data['delete'] = 1
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
assert_alert_exists(
response,
'danger',
'Error',
'NO_BOOKING No booking id for occurrence id %d.' % (
self.volunteer_opp.pk))
def test_post_form_valid_delete_allocation_w_bad_alloc(self):
data = self.get_edit_data()
data['alloc_id'] = self.alloc.pk + 100
data['delete'] = 1
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
assert_alert_exists(
response,
'danger',
'Error',
'BOOKING_NOT_FOUND Could not find booking id ' +
'%d for occurrence id %d.' % (self.alloc.pk + 100,
self.volunteer_opp.pk))
def test_post_form_edit_exiting_allocation(self):
new_volunteer = ProfileFactory()
data = self.get_edit_data()
data['worker'] = new_volunteer.pk,
data['role'] = 'Producer',
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
assert_email_template_used(
"A change has been made to your Volunteer Schedule!")
def test_post_form_edit_notification_template_fail(self):
EmailTemplateSenderFactory(
from_email="*****@*****.**",
template__name='volunteer schedule update',
template__subject="test template",
template__content="stuff {% url 'gbehome' %} more stuff"
)
new_volunteer = ProfileFactory()
data = self.get_edit_data()
data['worker'] = new_volunteer.pk,
data['role'] = 'Producer',
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(response,
volunteer_allocate_email_fail_msg)
def test_post_form_valid_make_new_allocation_w_confict(self):
data = self.get_create_data()
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
assert_alert_exists(
response,
'warning',
'Warning',
'SCHEDULE_CONFLICT <br>- Affected user: %s<br>- ' % (
self.volunteer.display_name) +
'Conflicting booking: %s, Start Time: %s' % (
self.volunteer_opp.eventitem.e_title,
'Fri, Feb 5 12:00 PM')
)
def test_post_form_valid_make_new_allocation_w_overfull(self):
data = self.get_create_data()
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(response, "Over booked by 1 volunteers")
def test_post_form_edit_w_conflict(self):
overbook_opp = self.context.add_volunteer_opp()
self.context.book_volunteer(
volunteer_sched_event=overbook_opp,
volunteer=self.volunteer)
data = self.get_edit_data()
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
assert_alert_exists(
response,
'warning',
'Warning',
'SCHEDULE_CONFLICT <br>- Affected user: %s<br>- ' % (
self.volunteer.display_name) +
'Conflicting booking: %s, Start Time: %s' % (
self.volunteer_opp.eventitem.e_title,
'Fri, Feb 5 12:00 PM')
)
