def set_staff_lead(self, staff_lead=None):
staff_lead = staff_lead or ProfileFactory()
ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(
_item=staff_lead,
role="Staff Lead"))
return staff_lead
def add_panelist(self, panelist=None):
panelist = panelist or PersonaFactory()
ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(
_item=panelist.workeritem_ptr,
role='Panelist'))
return panelist
def set_interest(self, interested_profile=None):
interested_profile = interested_profile or ProfileFactory()
ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(
_item=interested_profile,
role="Interested"))
return interested_profile
def schedule_instance(self, starttime=None, room=None, teacher=None):
room = room or self.room
teacher = teacher or self.teacher
if starttime:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr,
starttime=starttime)
elif self.sched_event:
one_day = timedelta(1)
sched_event = SchedEventFactory(
eventitem=self.bid.eventitem_ptr,
starttime=self.sched_event.starttime + one_day)
else:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr,
starttime=noon(self.days[0]))
ResourceAllocationFactory(
event=sched_event,
resource=LocationFactory(_item=room.locationitem_ptr))
ResourceAllocationFactory(event=sched_event,
resource=WorkerFactory(
_item=teacher.workeritem_ptr,
role='Teacher'))
EventLabelFactory(event=sched_event,
text=self.conference.conference_slug)
EventLabelFactory(event=sched_event, text="Conference")
return sched_event
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(_item=workeritem, role=role)
if eventitem:
event = SchedEventFactory.create(eventitem=eventitem)
else:
event = SchedEventFactory.create()
booking = ResourceAllocationFactory.create(event=event, resource=worker)
return booking
def test_show_interest_duplicate(self):
ResourceAllocationFactory(event=self.context.sched_event,
resource=WorkerFactory(_item=self.profile,
role="Interested"))
login_as(self.profile, self)
response = self.client.get(self.url, follow=True)
redirect_url = reverse('home', urlconf='gbe.urls')
self.assertRedirects(response, redirect_url)
self.assertContains(response, self.context.bid.e_title)
self.assertNotContains(response, set_favorite_msg)
def __init__(self,
performer=None,
act=None,
show=None,
sched_event=None,
conference=None,
room_name=None,
schedule_rehearsal=False,
act_role="Regular Act",
set_waitlist=False):
if conference:
self.show = show or ShowFactory(e_conference=conference)
else:
self.show = show or ShowFactory()
self.conference = conference or self.show.e_conference
self.performer = performer or PersonaFactory()
self.act = act or ActFactory(performer=self.performer,
b_conference=self.conference,
accepted=3,
submitted=True)
role = "Performer"
if set_waitlist:
self.act.accepted = 2
self.act.save()
act_role = "Waitlisted"
role = "Waitlisted"
self.tech = self.act.tech
# schedule the show
if sched_event:
self.sched_event = sched_event
else:
self.sched_event = SchedEventFactory(
eventitem=self.show.eventitem_ptr)
EventLabelFactory(event=self.sched_event,
text=self.conference.conference_slug)
room_name = room_name or "Dining Room"
self.room = RoomFactory(name=room_name)
self.room.conferences.add(self.conference)
if not sched_event:
ResourceAllocationFactory(
event=self.sched_event,
resource=LocationFactory(_item=self.room.locationitem_ptr))
# schedule the act into the show
self.booking = ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(
_item=self.act.performer,
role=role))
self.order = OrderingFactory(allocation=self.booking,
class_id=self.act.pk,
class_name="Act",
role=act_role)
if schedule_rehearsal:
self.rehearsal = self._schedule_rehearsal(self.sched_event,
self.act)
def book_act_item_for_show(actitem, eventitem):
booking = ResourceAllocationFactory.create(
event=SchedEventFactory.create(eventitem=eventitem),
resource=WorkerFactory.create(_item=actitem.performer,
role="Performer"))
order = OrderingFactory(allocation=booking,
class_id=actitem.pk,
class_name="Act")
EventLabelFactory(event=booking.event,
text=eventitem.e_conference.conference_slug)
EventLabelFactory(event=booking.event, text=eventitem.calendar_type)
return booking
def book_act(self, act=None, act_role='Regular Act'):
act = act or ActFactory(
b_conference=self.conference, accepted=3, submitted=True)
role = "Performer"
booking = ResourceAllocationFactory(
event=self.sched_event,
resource=WorkerFactory(_item=act.performer, role=role))
order = OrderingFactory(allocation=booking,
class_id=act.pk,
class_name="Act",
role=act_role)
return (act, booking)
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(_item=workeritem, role=role)
if eventitem:
event = SchedEventFactory.create(eventitem=eventitem)
else:
event = SchedEventFactory.create()
EventLabelFactory(event=event,
text=event.eventitem.e_conference.conference_slug)
EventLabelFactory(event=event, text=event.eventitem.calendar_type)
booking = ResourceAllocationFactory.create(event=event, resource=worker)
return booking
def book_volunteer(self,
volunteer_sched_event=None,
volunteer=None,
role="Volunteer"):
if not volunteer_sched_event:
volunteer_sched_event = self.add_volunteer_opp()
if not volunteer:
volunteer = ProfileFactory()
booking = ResourceAllocationFactory(event=volunteer_sched_event,
resource=WorkerFactory(
_item=volunteer, role=role))
return (volunteer, booking)
def __init__(self,
profile=None,
bid=None,
event=None,
opportunity=None,
role=None):
if not event:
self.window = VolunteerWindowFactory()
self.conference = self.window.day.conference
else:
self.conference = event.e_conference
if not VolunteerWindow.objects.filter(
day__conference=self.conference).exists():
self.window = VolunteerWindowFactory(
day__conference=self.conference)
else:
self.window = VolunteerWindow.objects.all().first()
self.conf_day = self.window.day
self.profile = profile or ProfileFactory()
if not hasattr(self.profile, 'preferences'):
ProfilePreferencesFactory(profile=self.profile)
if bid is False:
self.bid = None
elif bid:
self.bid = bid
self.profile = self.bid.profile
else:
self.bid = VolunteerFactory(
b_conference=self.conference,
profile=self.profile)
self.interest = VolunteerInterestFactory(
volunteer=self.bid)
self.event = event or ShowFactory(
e_conference=self.conference)
self.role = role or "Volunteer"
self.room = RoomFactory()
self.sched_event = SchedEventFactory(
eventitem=self.event.eventitem_ptr,
starttime=datetime.combine(self.window.day.day,
self.window.start))
ResourceAllocationFactory(
event=self.sched_event,
resource=LocationFactory(_item=self.room))
EventLabelFactory(event=self.sched_event,
text="General")
EventLabelFactory(event=self.sched_event,
text=self.conference.conference_slug)
self.worker = WorkerFactory(_item=self.profile.workeritem,
role=self.role)
self.opportunity, self.opp_event = self.add_opportunity(opportunity)
self.allocation = ResourceAllocationFactory(resource=self.worker,
event=self.opp_event)
def test_remove_interest(self):
self.url = reverse(self.view_name,
args=[self.context.sched_event.pk, "off"],
urlconf="gbe.scheduling.urls")
ResourceAllocationFactory(event=self.context.sched_event,
resource=WorkerFactory(_item=self.profile,
role="Interested"))
login_as(self.profile, self)
response = self.client.get(self.url, follow=True)
redirect_url = reverse('home', urlconf='gbe.urls')
self.assertRedirects(response, redirect_url)
self.assertNotContains(response, self.context.bid.e_title)
assert_alert_exists(response, 'success', 'Success', unset_favorite_msg)
def test_act_changestate_book_act_with_conflict(self):
grant_privilege(self.privileged_user, 'Act Reviewers')
conflict = SchedEventFactory(
starttime=self.context.sched_event.starttime)
ResourceAllocationFactory(
event=conflict,
resource=WorkerFactory(
_item=self.context.performer.performer_profile))
url = reverse(self.view_name,
args=[self.context.act.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data=self.data, follow=True)
self.assertContains(response, "is booked for")
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(
_item=workeritem,
role=role)
if eventitem:
event = SchedEventFactory.create(
eventitem=eventitem)
else:
event = SchedEventFactory.create()
booking = ResourceAllocationFactory.create(
event=event,
resource=worker
)
return booking
def test_personal_schedule_interest_booking(self):
'''a teacher booked into a class, with an active role condition
should have a booking
'''
role_condition = RoleEligibilityConditionFactory()
context = ClassContext()
profile = ProfileFactory()
booking = ResourceAllocationFactory(resource=WorkerFactory(
_item=profile, role="Interested"),
event=context.sched_event)
login_as(self.priv_profile, self)
response = self.client.get(
self.url, data={"conf_slug": context.conference.conference_slug})
self.assertContains(response, str(profile))
self.assertContains(response, context.bid.e_title, 2)
self.assertContains(response, "interested-sched")
def test_repeated_lead_shows_once(self):
show = ShowFactory()
sched_events = [
SchedEventFactory.create(eventitem=show.eventitem_ptr)
for i in range(2)
]
staff_lead = ProfileFactory()
lead_worker = WorkerFactory(_item=staff_lead.workeritem_ptr,
role="Staff Lead")
for se in sched_events:
ResourceAllocationFactory.create(event=se, resource=lead_worker)
response = self.client.get(
reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[show.eventitem_id]))
self.assertEqual(200, response.status_code)
self.assertEqual(1, response.content.count(staff_lead.display_name))
def __init__(self,
profile=None,
event=None,
sched_event=None,
opportunity=None,
role=None,
conference=None):
if not event:
self.conference = conference or ConferenceFactory()
else:
self.conference = event.e_conference
if ConferenceDay.objects.filter(conference=self.conference).exists():
self.conf_day = ConferenceDay.objects.filter(
conference=self.conference).first()
else:
self.conf_day = ConferenceDayFactory(conference=self.conference)
self.profile = profile or ProfileFactory()
if not hasattr(self.profile, 'preferences'):
ProfilePreferencesFactory(profile=self.profile)
self.role = role or "Volunteer"
self.room = RoomFactory()
self.room.conferences.add(self.conference)
self.event = event or ShowFactory(e_conference=self.conference)
if not sched_event:
self.sched_event = SchedEventFactory(
eventitem=self.event.eventitem_ptr,
starttime=datetime.combine(self.conf_day.day, time(12, 0, 0)))
ResourceAllocationFactory(
event=self.sched_event,
resource=LocationFactory(_item=self.room))
EventLabelFactory(event=self.sched_event, text="General")
EventLabelFactory(event=self.sched_event,
text=self.conference.conference_slug)
else:
self.sched_event = sched_event
self.worker = WorkerFactory(_item=self.profile.workeritem,
role=self.role)
self.opportunity, self.opp_event = self.add_opportunity(opportunity)
self.allocation = ResourceAllocationFactory(resource=self.worker,
event=self.opp_event)
def test_act_changestate_book_act_with_conflict(self):
# accepted -> waitlist (#2, see above)
# change show, change role
EmailTemplateSenderFactory(from_email="*****@*****.**",
template__name='act wait list',
template__subject="test template")
grant_privilege(self.privileged_user, 'Act Reviewers')
conflict = SchedEventFactory(
starttime=self.context.sched_event.starttime)
EventLabelFactory(event=conflict,
text=self.context.conference.conference_slug)
ResourceAllocationFactory(
event=conflict,
resource=WorkerFactory(
_item=self.context.performer.performer_profile))
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=self.data, follow=True)
self.assertContains(response,
"Conflicting booking: %s" % str(conflict))
assert_email_template_used("test template", "*****@*****.**")
def schedule_instance(self, starttime=None, room=None, moderator=None):
room = room or self.room
moderator = moderator or self.moderator
if starttime:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr,
starttime=starttime)
elif self.sched_event:
one_day = timedelta(1)
sched_event = SchedEventFactory(
eventitem=self.bid.eventitem_ptr,
starttime=self.sched_event.starttime + one_day)
else:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr)
ResourceAllocationFactory(
event=sched_event,
resource=LocationFactory(_item=room.locationitem_ptr))
ResourceAllocationFactory(event=sched_event,
resource=WorkerFactory(
_item=moderator.workeritem_ptr,
role='Moderator'))
return sched_event
def _schedule_rehearsal(self, s_event, act=None):
rehearsal = GenericEventFactory(type="Rehearsal Slot",
e_conference=self.conference)
rehearsal_event = SchedEventFactory(
eventitem=rehearsal.eventitem_ptr,
max_commitments=10,
starttime=self.sched_event.starttime)
event_container = EventContainerFactory(child_event=rehearsal_event,
parent_event=s_event)
EventLabelFactory(event=rehearsal_event,
text=self.conference.conference_slug)
if act:
booking = ResourceAllocationFactory(event=rehearsal_event,
resource=WorkerFactory(
_item=act.performer,
role="Performer"))
OrderingFactory(allocation=booking,
class_id=act.pk,
class_name="Act")
return rehearsal_event
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(
_item=workeritem,
role=role)
if eventitem:
event = SchedEventFactory.create(
eventitem=eventitem)
else:
event = SchedEventFactory.create()
EventLabelFactory(
event=event,
text=event.eventitem.e_conference.conference_slug
)
EventLabelFactory(
event=event,
text=event.eventitem.calendar_type
)
booking = ResourceAllocationFactory.create(
event=event,
resource=worker
)
return booking
def post_conflict(self, staff=True):
context = VolunteerContext()
change_window = context.add_window()
if staff:
worker = WorkerFactory(
_item=context.profile,
role='Staff Lead'
)
ResourceAllocationFactory(
event=context.sched_event,
resource=worker)
context.bid.available_windows.add(context.window)
form = self.get_form(context)
form['available_windows'] = [change_window.pk]
url = reverse('volunteer_edit',
urlconf='gbe.urls',
args=[context.bid.pk])
login_as(context.profile, self)
response = self.client.post(
url,
form,
follow=True)
return response, context
def setUp(self):
self.client = Client()
# Conference Setup
self.factory = RequestFactory()
self.current_conf = ConferenceFactory(accepting_bids=True,
status='upcoming')
self.previous_conf = ConferenceFactory(accepting_bids=False,
status='completed')
# User/Human setup
self.profile = ProfileFactory()
self.performer = PersonaFactory(performer_profile=self.profile,
contact=self.profile)
# Bid types previous and current
self.current_act = ActFactory(performer=self.performer,
submitted=True,
b_conference=self.current_conf)
self.previous_act = ActFactory(performer=self.performer,
submitted=True,
b_conference=self.previous_conf)
self.current_class = ClassFactory(teacher=self.performer,
submitted=True,
accepted=3,
b_conference=self.current_conf,
e_conference=self.current_conf)
self.previous_class = ClassFactory(teacher=self.performer,
submitted=True,
accepted=3,
b_conference=self.previous_conf,
e_conference=self.previous_conf)
self.current_vendor = VendorFactory(profile=self.profile,
submitted=True,
b_conference=self.current_conf)
self.previous_vendor = VendorFactory(profile=self.profile,
submitted=True,
b_conference=self.previous_conf)
self.current_costume = CostumeFactory(profile=self.profile,
submitted=True,
b_conference=self.current_conf)
self.previous_costume = CostumeFactory(profile=self.profile,
submitted=True,
b_conference=self.previous_conf)
self.current_volunteer = VolunteerFactory(
profile=self.profile,
submitted=True,
b_conference=self.current_conf)
self.previous_volunteer = VolunteerFactory(
profile=self.profile,
submitted=True,
b_conference=self.previous_conf)
# Event assignments, previous and current
current_opportunity = GenericEventFactory(
e_conference=self.current_conf, type='Volunteer')
previous_opportunity = GenericEventFactory(
e_conference=self.previous_conf)
self.current_sched = SchedEventFactory(eventitem=current_opportunity,
starttime=datetime(
2016, 2, 5, 12, 30, 0, 0,
pytz.utc),
max_volunteer=10)
self.previous_sched = SchedEventFactory(eventitem=previous_opportunity,
starttime=datetime(
2015, 2, 25, 12, 30, 0, 0,
pytz.utc),
max_volunteer=10)
self.current_class_sched = SchedEventFactory(
eventitem=self.current_class,
starttime=datetime(2016, 2, 5, 2, 30, 0, 0, pytz.utc),
max_volunteer=10)
self.previous_class_sched = SchedEventFactory(
eventitem=self.previous_class,
starttime=datetime(2015, 2, 25, 2, 30, 0, 0, pytz.utc),
max_volunteer=10)
worker = WorkerFactory(_item=self.profile, role='Volunteer')
for schedule_item in [self.current_sched, self.previous_sched]:
volunteer_assignment = ResourceAllocationFactory(
event=schedule_item, resource=worker)
LabelFactory(text="label %d" % volunteer_assignment.pk,
allocation=volunteer_assignment)
persona_worker = WorkerFactory(_item=self.performer, role='Teacher')
for schedule_item in [
self.current_class_sched, self.previous_class_sched
]:
volunteer_assignment = ResourceAllocationFactory(
event=schedule_item, resource=worker)
def make_priv_role(self, role="Stage Manager"):
profile = ProfileFactory()
ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(role=role,
_item=profile))
return profile
def set_producer(self, producer=None):
producer = producer or ProfileFactory()
ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(_item=producer,
role="Producer"))
return producer