예제 #1
0
 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
예제 #2
0
    def add_volunteer_opp(self, volunteer_sched_event=None, room=None):
        if not self.conference.conferenceday_set.exists():
            if volunteer_sched_event:
                self.conf_day = ConferenceDayFactory(
                    day=volunteer_sched_event.starttime.date(),
                    conference=self.conference)
            else:
                self.conf_day = ConferenceDayFactory(
                    conference=self.conference)
        else:
            self.conf_day = self.conference.conferenceday_set.first()
        if not volunteer_sched_event:
            vol_event = GenericEventFactory(e_conference=self.conference,
                                            type="Volunteer")
            volunteer_sched_event = SchedEventFactory(
                eventitem=vol_event,
                max_volunteer=self.area.default_volunteers,
                starttime=noon(self.conf_day))
        if not room:
            room = RoomFactory()

        ResourceAllocationFactory(event=volunteer_sched_event,
                                  resource=LocationFactory(_item=room))
        EventLabelFactory(event=volunteer_sched_event, text=self.area.slug)
        EventLabelFactory(event=volunteer_sched_event,
                          text=self.conference.conference_slug)
        EventLabelFactory(event=volunteer_sched_event, text="Volunteer")
        return volunteer_sched_event
예제 #3
0
    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)
예제 #4
0
    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)
예제 #5
0
 def schedule_instance(self, starttime=None, room=None):
     room = room or self.room
     if starttime:
         sched_event = SchedEventFactory(eventitem=self.show.eventitem_ptr,
                                         starttime=starttime)
     else:
         sched_event = SchedEventFactory(eventitem=self.show.eventitem_ptr,
                                         starttime=noon(self.days[0]))
     EventLabelFactory(event=sched_event,
                       text=self.conference.conference_slug)
     EventLabelFactory(event=sched_event, text="General")
     ResourceAllocationFactory(
         event=sched_event,
         resource=LocationFactory(_item=room.locationitem_ptr))
     return sched_event
예제 #6
0
    def make_rehearsal(self, room=True):
        rehearsal = GenericEventFactory(e_conference=self.conference,
                                        type='Rehearsal Slot')
        start_time = datetime.combine(self.days[0].day,
                                      (self.sched_event.start_time -
                                       timedelta(hours=4)).time())

        slot = SchedEventFactory(eventitem=rehearsal.eventitem_ptr,
                                 starttime=start_time,
                                 max_volunteer=10)
        if room:
            ResourceAllocationFactory(
                event=slot, resource=LocationFactory(_item=self.room))
        EventContainerFactory(parent_event=self.sched_event, child_event=slot)
        EventLabelFactory(event=slot, text=self.conference.conference_slug)
        return rehearsal, slot
예제 #7
0
    def add_opportunity(self, opportunity=None, start_time=None):
        opportunity = opportunity or GenericEventFactory(
            e_conference=self.conference, type='Volunteer')
        start_time = start_time or datetime.combine(self.conf_day.day,
                                                    time(12, 0, 0))

        opp_event = SchedEventFactory(eventitem=opportunity.eventitem_ptr,
                                      starttime=start_time,
                                      max_volunteer=2)
        ResourceAllocationFactory(event=opp_event,
                                  resource=LocationFactory(_item=self.room))
        EventContainerFactory(parent_event=self.sched_event,
                              child_event=opp_event)
        EventLabelFactory(event=opp_event,
                          text=self.conference.conference_slug)
        EventLabelFactory(event=opp_event, text="Volunteer")
        return opportunity, opp_event
예제 #8
0
    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)
예제 #9
0
 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
예제 #10
0
 def __init__(self,
              performer=None,
              act=None,
              show=None,
              sched_event=None,
              conference=None,
              room_name=None,
              cue_count=1,
              schedule_rehearsal=False,
              act_role=""):
     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)
     self.tech = self.act.tech
     self.audio = self.tech.audio
     self.lighting = self.tech.lighting
     self.stage = self.tech.stage
     for i in range(cue_count):
         CueInfoFactory.create(techinfo=self.tech, cue_sequence=i)
     # schedule the show
     self.sched_event = sched_event or SchedEventFactory(
         eventitem=self.show.eventitem_ptr)
     room_name = room_name or "Dining Room"
     self.room = RoomFactory(name=room_name)
     if not sched_event:
         ResourceAllocationFactory(
             event=self.sched_event,
             resource=LocationFactory(_item=self.room.locationitem_ptr))
     # schedule the act into the show
     ResourceAllocationFactory(event=self.sched_event,
                               resource=ActResourceFactory(
                                   _item=self.act.actitem_ptr,
                                   role=act_role))
     if schedule_rehearsal:
         self.rehearsal = self._schedule_rehearsal(self.sched_event,
                                                   self.act)
 def test_get_allocation_no_locationresource_child(self):
     allocation = ResourceAllocationFactory(resource=LocationFactory())
     response = self.client.get('/admin/scheduler/resourceallocation/',
                                follow=True)
     self.assertContains(response, "No Location Item")