def test_get_act_w_label(self): context = ShowContext() act, booking = context.book_act() label = LabelFactory(allocation=booking) response = get_schedule( user=act.performer.performer_profile.user_object) self.assertEqual(response.schedule_items[0].label.text, label.text)
def get(self, request, *args, **kwargs): context = self.process_inputs(request, args, kwargs) personal_schedule = [] eval_occurrences = [] if not self.conference or not self.this_day or not self.calendar_type: return render(request, self.template, context) response = get_occurrences( labels=[self.calendar_type, self.conference.conference_slug], day=self.this_day.day) show_general_status(request, response, self.__class__.__name__) if len(response.occurrences) > 0: if request.user.is_authenticated() and hasattr( request.user, 'profile'): sched_response = get_schedule( request.user, labels=[ self.calendar_type, self.conference.conference_slug ]) personal_schedule = sched_response.schedule_items person = Person(user=request.user, public_id=request.user.profile.pk, public_class="Profile") eval_response = get_eval_info(person=person) if len(eval_response.questions) > 0: eval_occurrences = eval_response.occurrences else: eval_occurrences = None max_block_size, context[ 'occurrences'] = self.build_occurrence_display( response.occurrences, personal_schedule, eval_occurrences) grid_size = 2 if max_block_size < 6: grid_size = self.grid_map[max_block_size] context['grid_size'] = grid_size return render(request, self.template, context)
def get(self, request, *args, **kwargs): self.groundwork(request, args, kwargs) schedules = [] for person in self.profiles: response = get_schedule(person.user_object, labels=[self.conference.conference_slug]) if len(response.schedule_items) > 0 or len(self.profiles) == 1: ticket_items, role_items = get_checklist_items( person, self.conference) schedules += [{ 'person': person, 'bookings': response.schedule_items, 'ticket_items': ticket_items, 'role_items': role_items }] sorted_sched = sorted( schedules, key=lambda schedule: schedule['person'].get_badge_name()) return render( request, 'gbe/report/printable_schedules.tmpl', { 'schedules': sorted_sched, 'conference_slugs': conference_slugs(), 'conference': self.conference })
def groundwork(self, request, args, kwargs): self.shows = [] self.rehearsals = {} self.next_page = request.GET.get('next', reverse('home', urlconf='gbe.urls')) profile = validate_profile(request, require=False) if not profile: return HttpResponseRedirect( reverse('profile_update', urlconf='gbe.urls')) act_id = kwargs.get("act_id") self.act = get_object_or_404(Act, id=act_id) if self.act.performer.contact != profile: validate_perms(request, self.permissions) response = get_schedule(labels=[self.act.b_conference.conference_slug], commitment=self.act) for item in response.schedule_items: # group acts will have multiple items for same show if item.event not in self.shows and Show.objects.filter( eventitem_id=item.event.eventitem.eventitem_id).exists(): self.shows += [item.event] elif GenericEvent.objects.filter( eventitem_id=item.event.eventitem.eventitem_id, type='Rehearsal Slot').exists(): show_key = item.event.container_event.parent_event.pk self.rehearsals[show_key] = item if len(self.shows) == 0: raise Http404
def test_both_match(self): ''' profile meets role and ticket ''' teacher = PersonaFactory() booking = book_worker_item_for_role(teacher, self.role_condition.role) conference = booking.event.eventitem.get_conference() purchaser = PurchaserFactory( matched_to_user=teacher.performer_profile.user_object) transaction = TransactionFactory(purchaser=purchaser) transaction.ticket_item.ticketing_event.conference = conference transaction.ticket_item.ticketing_event.save() self.ticket_condition.tickets.add(transaction.ticket_item) self.ticket_condition.save() self.schedule = get_schedule(teacher.performer_profile.user_object, labels=[conference.conference_slug ]).schedule_items ticket_items, role_items = get_checklist_items( teacher.performer_profile, conference, self.schedule) nt.assert_equal(len(ticket_items), 1) nt.assert_equal(len(role_items), 1) nt.assert_equal(ticket_items[0]['ticket'], transaction.ticket_item.title) nt.assert_equal(role_items[self.role_condition.role], [self.role_condition.checklistitem])
def test_get_act_w_label(self): context = ShowContext() act, booking = context.book_act() label = LabelFactory(allocation=booking) response = get_schedule( user=act.performer.performer_profile.user_object) self.assertEqual(response.schedule_items[0].label.text, label.text)
def schedule_email(): personal_schedules = {} boston_today = datetime.now(tz=pytz.timezone('America/New_York')).date() target_day = boston_today + timedelta(days=1) try: conf_day = ConferenceDay.objects.get(day=target_day) except ConferenceDay.DoesNotExist: return 0 sched_resp = get_schedule( start_time=datetime.combine( target_day, time(0, 0, 0, 0, tzinfo=pytz.utc)), end_time=datetime.combine( target_day+timedelta(days=1), time(0, 0, 0, 0, tzinfo=pytz.utc))) for item in sched_resp.schedule_items: if item.user in personal_schedules: personal_schedules[item.user] += [item] else: personal_schedules[item.user] = [item] send_daily_schedule_mail( personal_schedules, target_day, conf_day.conference.conference_slug) return len(personal_schedules)
def test_get_teacher_w_label(self): context = ClassContext() booking = ResourceAllocation.objects.get( event=context.sched_event, resource__worker__role='Teacher') label = LabelFactory(allocation=booking) response = get_schedule( user=context.teacher.performer_profile.user_object) self.assertEqual(response.schedule_items[0].label.text, label.text)
def get(self, request, *args, **kwargs): eventitem_id = kwargs['eventitem_id'] schedule_items = [] personal_schedule_items = [] eventitem_view = get_event_display_info(eventitem_id) person = None eval_occurrences = [] if request.user.is_authenticated and hasattr(request.user, 'profile'): person = Person( user=request.user, public_id=request.user.profile.pk, public_class="Profile") all_roles = [] for n, m in role_options: all_roles += [m] personal_schedule_items = get_schedule( request.user, labels=[ eventitem_view['event'].calendar_type, eventitem_view['event'].e_conference.conference_slug], roles=all_roles, ).schedule_items if eventitem_view['event'].calendar_type == "Conference": eval_response = get_eval_info(person=person) if len(eval_response.questions) > 0: eval_occurrences = eval_response.occurrences else: eval_occurrences = None for occurrence in eventitem_view['scheduled_events']: (favorite_link, volunteer_link, evaluate, highlight, vol_disable_msg) = build_icon_links( occurrence, eval_occurrences, eventitem_view['event'].calendar_type, (eventitem_view['event'].e_conference.status == "completed"), personal_schedule_items) schedule_items += [{ 'occurrence': occurrence, 'favorite_link': favorite_link, 'volunteer_link': volunteer_link, 'highlight': highlight, 'evaluate': evaluate, 'approval_needed': occurrence.approval_needed, 'vol_disable_msg': vol_disable_msg, }] template = 'gbe/scheduling/event_detail.tmpl' return render(request, template, {'eventitem': eventitem_view, 'show_tickets': True, 'tickets': eventitem_view['event'].get_tickets, 'user_id': request.user.id, 'schedule_items': schedule_items})
def setUp(self): self.role_condition = RoleEligibilityConditionFactory() self.teacher = PersonaFactory() booking = book_worker_item_for_role(self.teacher, self.role_condition.role) self.conference = booking.event.eventitem.get_conference() self.schedule = get_schedule( self.teacher.performer_profile.user_object, labels=[self.conference.conference_slug]).schedule_items
def test_get_teacher_w_label(self): context = ClassContext() booking = ResourceAllocation.objects.get( event=context.sched_event, resource__worker__role='Teacher') label = LabelFactory(allocation=booking) response = get_schedule( user=context.teacher.performer_profile.user_object) self.assertEqual(response.schedule_items[0].label.text, label.text)
def test_no_role(self): ''' purchaser has no roles ''' no_match_profile = ProfileFactory() no_schedule = get_schedule(no_match_profile.user_object, labels=[self.conference.conference_slug ]).schedule_items checklist_items = get_checklist_items_for_roles(no_schedule, []) nt.assert_equal(len(checklist_items), 0)
def get_shows(self): from gbe.models import Show # late import, circularity acts = self.get_acts() shows = [] for act in acts: if act.accepted == 3 and act.is_current: for item in get_schedule(commitment=act).schedule_items: for show in Show.objects.filter( eventitem_id=item.event.eventitem.eventitem_id): shows += [(show, act)] shows = sorted(shows, key=lambda show: show[0].e_title) return shows
def groundwork(self, request, args, kwargs): groundwork_data = shared_groundwork(request, kwargs, self.view_perm) if groundwork_data is None: error_url = reverse('home', urlconf='gbe.urls') return HttpResponseRedirect(error_url) else: (self.profile, self.occurrence, self.item) = groundwork_data self.can_schedule_acts = validate_perms(request, self.schedule_act_perm, require=False) self.can_change_techinfo = validate_perms(request, self.change_tech_perm, require=False) self.can_rebook = validate_perms(request, self.rebook_perm, require=False) self.can_approve_vol = validate_perms(request, self.approve_volunteers, require=False) self.can_assign_act = request.user.has_perm( 'gbe.assign_act') or validate_perms( request, self.assign_act_perm, require=False) self.show_scope = [] if validate_perms(request, self.cross_show_scope, require=False): self.show_scope = get_occurrences( foreign_event_ids=Show.objects.filter( e_conference=self.item.e_conference).values_list( 'eventitem_id', flat=True)).occurrences else: check_scope = False for item in get_schedule(user=self.profile.user_object, roles=self.view_perm).schedule_items: self.show_scope += [item.event] if item.event == self.occurrence: check_scope = True if not check_scope: messages.error( request, UserMessage.objects.get_or_create( view=self.__class__.__name__, code="NO_SHOW_SCOPE_PRIVILEGE", defaults={ 'summary': "User is accesing show they don't manage", 'description': no_scope_error })[0].description) error_url = reverse('home', urlconf='gbe.urls') return HttpResponseRedirect(error_url)
def test_role_match(self): ''' profile has a role match condition ''' teacher = PersonaFactory() booking = book_worker_item_for_role(teacher, self.role_condition.role) conference = booking.event.eventitem.get_conference() self.schedule = get_schedule(teacher.performer_profile.user_object, labels=[conference.conference_slug ]).schedule_items ticket_items, role_items = get_checklist_items( teacher.performer_profile, conference, self.schedule) nt.assert_equal(len(role_items), 1) nt.assert_equal(role_items[self.role_condition.role], [self.role_condition.checklistitem])
def setUp(self): clear_conferences() self.factory = RequestFactory() self.client = Client() self.ticketingexclusion = TicketingExclusionFactory.create() self.roleexclusion = RoleExclusionFactory.create() self.teacher = PersonaFactory.create() booking = book_worker_item_for_role( self.teacher, self.roleexclusion.role, ) self.roleexclusion.event = booking.event.eventitem self.roleexclusion.save() self.conference = booking.event.eventitem.get_conference() self.schedule = get_schedule( self.teacher.performer_profile.user_object, labels=[self.conference.conference_slug]).schedule_items
def test_no_checklist(self): ''' profile matches no conditions ''' no_match_profile = ProfileFactory() transaction = TransactionFactory() conf = transaction.ticket_item.ticketing_event.conference self.ticket_condition.tickets.add(transaction.ticket_item) no_schedule = get_schedule(no_match_profile.user_object, labels=[conf.conference_slug ]).schedule_items ticket_items, role_items = get_checklist_items( no_match_profile, transaction.ticket_item.ticketing_event.conference, no_schedule) nt.assert_equal(len(ticket_items), 0) nt.assert_equal(len(role_items), 0)
def test_role_exclusion(self): ''' a condition matches this circumstance, but is excluded ''' exclusion = NoEventRoleExclusionFactory(condition=self.role_condition, role="Staff Lead") booking = book_worker_item_for_role( self.teacher.performer_profile, exclusion.role, GenericEventFactory(e_conference=self.conference)) self.schedule = get_schedule( self.teacher.performer_profile.user_object, labels=[self.conference.conference_slug]).schedule_items checklist_items = get_checklist_items_for_roles(self.schedule, []) nt.assert_equal(len(checklist_items), 0)
def create_action_form(self, act): self.actionform = self.bid_state_change_form(instance=act) start = 0 casting = "" for item in get_schedule(commitment=act, roles=["Performer", "Waitlisted"]).schedule_items: if item.event.event_type_name == "Show": start = item.event.eventitem.pk casting = item.commitment.role self.actionform = make_show_casting_form(act.b_conference, self.actionform, start, casting) self.actionURL = reverse(self.changestate_view_name, urlconf='gbe.urls', args=[act.id]) self.reviewers = Profile.objects.filter( flexibleevaluation__bid=act).order_by('display_name').distinct() evaluations = FlexibleEvaluation.objects.filter(bid=act) self.review_results = OrderedDict() for category in self.categories: self.review_results[category] = [] for reviewer in self.reviewers: try: self.review_results[category] += [ evaluations.get(category=category, evaluator=reviewer, ranking__gt=-1).ranking ] except: self.review_results[category] += [""] try: self.review_results[category] += [ round( evaluations.filter(category=category, ranking__gt=-1).aggregate( Avg('ranking'))['ranking__avg'], 2) ] except: self.review_results[category] += [""] self.notes = ActBidEvaluation.objects.filter(bid=act).order_by( 'evaluator', )
def get(self, request, *args, **kwargs): context = self.process_inputs(request, args, kwargs) personal_schedule = [] if not self.conference or not self.this_day: return render(request, self.template, context) response = get_occurrences( labels=["Volunteer", self.conference.conference_slug], day=self.this_day.day, max_volunteer=1) show_general_status(request, response, self.__class__.__name__) if len(response.occurrences) > 0: if request.user.is_authenticated and hasattr( request.user, 'profile'): all_roles = [] for n, m in role_options: all_roles += [m] sched_response = get_schedule( request.user, labels=["Volunteer", self.conference.conference_slug], roles=all_roles) personal_schedule = sched_response.schedule_items person = Person(user=request.user, public_id=request.user.profile.pk, public_class="Profile") eval_response = get_eval_info(person=person) context['occurrences'] = self.build_occurrence_display( response.occurrences, personal_schedule) context['col_per_hour'] = self.col_per_hour context['grid_list'] = self.make_time_range( self.start_grid_hour * 60, self.end_grid_hour * 60, int(60 / self.col_per_hour)) if self.next_day_end: # hack to roll around the clock context['grid_list'] += self.make_time_range( self.end_grid_hour * 60, (self.end_grid_hour + 1) * 60, int(60 / self.col_per_hour)) context['grid_list'] += self.make_time_range( 0, self.next_day_end * 60, int(60 / self.col_per_hour), True) context['col_fraction'] = 100.0 / len(context['grid_list']) return render(request, self.template, context)
def test_ticket_match(self): ''' profile has a ticket match condition ''' transaction = TransactionFactory() purchaser = ProfileFactory( user_object=transaction.purchaser.matched_to_user) conference = transaction.ticket_item.ticketing_event.conference self.ticket_condition.tickets.add(transaction.ticket_item) self.ticket_condition.save() self.schedule = get_schedule(purchaser.user_object, labels=[conference.conference_slug ]).schedule_items ticket_items, role_items = get_checklist_items(purchaser, conference, self.schedule) nt.assert_equal(len(ticket_items), 1) nt.assert_equal(ticket_items[0]['items'], [self.ticket_condition.checklistitem])
def act_techinfo_detail(request, act_id): ''' Show the info for a specific act ''' shows = [] rehearsals = [] order = -1 act = get_object_or_404(Act, pk=act_id) # if this isn't a privileged user, it had better be a member of the # troupe or the performer. if not validate_perms(request, ('Scheduling Mavens', 'Stage Manager', 'Tech Crew', 'Technical Director', 'Producer'), require=False): profile = validate_profile(request) if profile not in act.performer.get_profiles(): raise PermissionDenied if act.accepted == 3: response = get_schedule(labels=[act.b_conference.conference_slug], commitment=act) show_general_status(request, response, "ActTechinfoDetail") for item in response.schedule_items: if item.event not in shows and Show.objects.filter( eventitem_id=item.event.eventitem.eventitem_id).exists(): shows += [item.event] order = item.commitment.order elif item.event not in rehearsals and GenericEvent.objects.filter( eventitem_id=item.event.eventitem.eventitem_id, type='Rehearsal Slot').exists(): rehearsals += [item.event] return render( request, 'gbe/report/act_tech_detail.tmpl', { 'act': act, 'state': acceptance_states[act.accepted][1], 'shows': shows, 'order': order, 'rehearsals': rehearsals })
def manage_schedule_problems(self, changed_windows, profile): warnings = [] conflicts = [] for window in changed_windows: conflict_check = get_schedule( profile.user_object, start_time=window.start_time, end_time=window.end_time, labels=[self.bid_object.b_conference.conference_slug]) # choosing to error silently here, because the function does not # have any errors yet, and because this is a public user case for conflict in conflict_check.schedule_items: if ((conflict.event not in conflicts) and conflict.role == "Volunteer"): conflicts += [conflict.event] warning = { 'time': conflict.event.starttime.strftime( DATETIME_FORMAT), 'event': str(conflict.event), 'interest': conflict.event.eventitem.child( ).volunteer_category_description, } leads = get_all_container_bookings( occurrence_ids=[conflict.event.pk], roles=['Staff Lead', ]) for lead in leads.people: warning['lead'] = str(lead.user.profile.badge_name) warning['email'] = lead.user.email for area in StaffArea.objects.filter( conference=self.bid_object.b_conference, slug__in=conflict.event.labels.values_list( 'text', flat=True)): warning['lead'] = area.staff_lead.badge_name warning['email'] = area.staff_lead.user_object.email response = remove_booking( occurrence_id=conflict.event.pk, booking_id=conflict.booking_id) warnings += [warning] return warnings
def test_multiple_role_match_happens(self): ''' profile meets 2 role conditions ''' another_role = RoleEligibilityConditionFactory(role="Staff Lead") booking = book_worker_item_for_role( self.teacher.performer_profile, another_role.role, GenericEventFactory(e_conference=self.conference)) self.schedule = get_schedule( self.teacher.performer_profile.user_object, labels=[self.conference.conference_slug]).schedule_items checklist_items = get_checklist_items_for_roles(self.schedule, []) nt.assert_equal(len(checklist_items), 2) nt.assert_equal(checklist_items['Teacher'], [self.role_condition.checklistitem]) nt.assert_equal(checklist_items["Staff Lead"], [another_role.checklistitem]) another_role.delete()
def schedule_email(): email_type = 'daily_schedule' personal_schedules = {} boston_today = datetime.now().date() target_day = boston_today + timedelta(days=1) try: conf_day = ConferenceDay.objects.get(day=target_day) except ConferenceDay.DoesNotExist: return 0 sched_resp = get_schedule( start_time=datetime.combine(target_day, time(0, 0, 0, 0)), end_time=datetime.combine(target_day + timedelta(days=1), time(0, 0, 0, 0))) for item in sched_resp.schedule_items: if item.user.profile.email_allowed(email_type): if item.user in personal_schedules: personal_schedules[item.user] += [item] else: personal_schedules[item.user] = [item] send_daily_schedule_mail(personal_schedules, target_day, conf_day.conference.conference_slug, email_type) return len(personal_schedules)
def get(self, request, *args, **kwargs): context = self.process_inputs(request, args, kwargs) personal_schedule = [] eval_occurrences = [] if not self.conference or not self.this_day or not self.calendar_type: return render(request, self.template, context) response = get_occurrences( labels=[self.calendar_type, self.conference.conference_slug], day=self.this_day.day) show_general_status( request, response, self.__class__.__name__) if len(response.occurrences) > 0: if request.user.is_authenticated() and hasattr( request.user, 'profile'): sched_response = get_schedule( request.user, labels=[self.calendar_type, self.conference.conference_slug]) personal_schedule = sched_response.schedule_items person = Person( user=request.user, public_id=request.user.profile.pk, public_class="Profile") eval_response = get_eval_info(person=person) if len(eval_response.questions) > 0: eval_occurrences = eval_response.occurrences else: eval_occurrences = None max_block_size, context[ 'occurrences'] = self.build_occurrence_display( response.occurrences, personal_schedule, eval_occurrences) grid_size = 2 if max_block_size < 6: grid_size = self.grid_map[max_block_size] context['grid_size'] = grid_size return render(request, self.template, context)
def get(self, request, *args, **kwargs): self.groundwork(request, args, kwargs) schedules = [] for person in self.profiles: response = get_schedule( person.user_object, labels=[self.conference.conference_slug]) if len(response.schedule_items) > 0 or len(self.profiles) == 1: ticket_items, role_items = get_checklist_items(person, self.conference) schedules += [{'person': person, 'bookings': response.schedule_items, 'ticket_items': ticket_items, 'role_items': role_items}] sorted_sched = sorted( schedules, key=lambda schedule: schedule['person'].get_badge_name()) return render(request, 'gbe/report/printable_schedules.tmpl', {'schedules': sorted_sched, 'conference_slugs': conference_slugs(), 'conference': self.conference})
def get(self, request, *args, **kwargs): error_url = self.groundwork(request, args, kwargs) if error_url: return error_url header = [ 'Order', 'Performer', 'Title', 'Duration (HH:MM:SS)', 'Starting Position', 'Prop Setup', 'Pronouns', 'Read Intro Exactly', 'Intro Text', 'Costume Colors', 'Starting Lights', 'Follow Spot', 'Wash Color', 'Background Color', 'Cue for light change', 'Lighting at End', 'Track Title', 'Track Artist', 'Mic Options' ] tech_info = [] response = get_people(foreign_event_ids=[self.item.eventitem_id], roles=["Performer"]) show_general_status(request, response, self.__class__.__name__) for performer in response.people: read_exact = "No" light_start = "Lights On" light_end = "Lights On" prop_setup_list = "" follow_spot = "OFF" wash = "No selection made" background = "No selection made" cue = "NONE" order = -1 act = get_object_or_404(Act, pk=performer.commitment.class_id) sched_response = get_schedule( labels=[act.b_conference.conference_slug], commitment=act) show_general_status(request, sched_response, self.__class__.__name__) for item in sched_response.schedule_items: if Show.objects.filter(eventitem_id=item.event.eventitem. eventitem_id).exists(): order = item.commitment.order if act.tech.prop_setup: for item in act.tech.prop_setup_list: if len(prop_setup_list) == 0: prop_setup_list = item else: prop_setup_list = "%s, %s" % (prop_setup_list, item) prop_setup_list = "%s\n%s" % (prop_setup_list, act.tech.crew_instruct) else: prop_setup_list = act.tech.crew_instruct if act.tech.read_exact: read_exact = "Yes" if act.tech.start_blackout: light_start = "Blackout" if act.tech.end_blackout: light_end = "Blackout" if act.tech.follow_spot_color: follow_spot = act.tech.follow_spot_color if act.tech.wash_color: wash = act.tech.wash_color if act.tech.background_color: background = act.tech.background_color if act.tech.special_lighting_cue: cue = act.tech.special_lighting_cue if act.tech.confirm_no_music: title = "no music" artist = "" else: title = act.tech.track_title artist = act.tech.track_artist tech_info.append([ order, str(act.performer), act.b_title, act.tech.duration, act.tech.starting_position, prop_setup_list, act.tech.pronouns, read_exact, act.tech.introduction_text, "Primary: %s\nSecondary: %s" % (act.tech.primary_color, act.tech.secondary_color), light_start, follow_spot, wash, background, cue, light_end, title, artist, act.tech.mic_choice, ]) response = HttpResponse(content_type='text/csv') response[ 'Content-Disposition'] = 'attachment; filename=%s_tech.csv' % (str( self.item)) writer = csv.writer(response) writer.writerow(header) for row in tech_info: writer.writerow(row) return response
def allocate_person(self, person): ''' allocated worker for the new model - right now, focused on create uses the Person from the data_transfer objects. ''' from scheduler.idd import get_schedule from scheduler.models import ( Ordering, ResourceAllocation, ) warnings = [] time_format = GBE_DATETIME_FORMAT worker = None if person.public_id: item = WorkerItem.objects.get(pk=person.public_id) worker = Worker(_item=item, role=person.role) else: worker = Worker(_item=person.user.profile, role=person.role) # TODO is there a leak here? what happens to old workers # that aren't linked?? worker.save() if person.users: users = person.users else: users = [worker.workeritem.user_object] for user in users: for conflict in get_schedule( user=user, start_time=self.start_time, end_time=self.end_time).schedule_items: if not person.booking_id or (person.booking_id != conflict.booking_id): warnings += [ Warning(code="SCHEDULE_CONFLICT", user=user, occurrence=conflict.event) ] if person.booking_id: allocation = ResourceAllocation.objects.get(id=person.booking_id) allocation.resource = worker allocation.event = self else: allocation = ResourceAllocation(event=self, resource=worker) allocation.save() if person.commitment: ordering, created = Ordering.objects.get_or_create( allocation=allocation) if person.commitment.role is not None: ordering.role = person.commitment.role if person.commitment.order: ordering.order = person.commitment.order ordering.class_name = person.commitment.class_name ordering.class_id = person.commitment.class_id ordering.save() if self.extra_volunteers() > 0: warnings += [ Warning(code="OCCURRENCE_OVERBOOKED", details="Over booked by %s volunteers" % (self.extra_volunteers())) ] if person.label: # refactor from scheduler.models import Label l, created = Label.objects.get_or_create(allocation=allocation) l.text = person.label l.save() return BookingResponse(warnings=warnings, booking_id=allocation.pk, occurrence=self)
def bid_state_change(self, request): show = None rehearsals = [] # Determine if the current show should be changed if self.object.accepted in self.show_booked_states: response = get_schedule(commitment=self.object, roles=["Performer", "Waitlisted"]) show_general_status(request, response, self.__class__.__name__) show, rehearsals = self.parse_act_schedule(response.schedule_items) # if the act has been accepted, set the show. if self.act_accepted(request): # Cast the act into the show by adding it to the schedule # resource time if ('casting' not in request.POST) or ( request.POST['casting'] != '' and ActCastingOption.objects.filter( casting=request.POST['casting']).count() == 0): user_message = UserMessage.objects.get_or_create( view=self.__class__.__name__, code="INVALID_CASTING", defaults={ 'summary': "Casting Role Incorrect", 'description': no_casting_msg }) messages.error(request, user_message[0].description) return HttpResponseRedirect( reverse("act_review", urlconf='gbe.urls', args=[self.object.pk])) casting = request.POST['casting'] role = "Performer" if request.POST['accepted'] == '2': casting = "Waitlisted" role = "Waitlisted" same_show = False same_role = False if show and show.event.eventitem == self.new_show.eventitem: same_show = True if casting == show.commitment.role: user_message = UserMessage.objects.get_or_create( view=self.__class__.__name__, code="ACT_NO_CHANGE", defaults={ 'summary': "Act State Not Changed", 'description': act_status_no_change_msg }) messages.success( request, "%s<br>Performer/Act: %s - %s" % (user_message[0].description, self.object.performer.name, self.object.b_title)) return super(ActChangeStateView, self).bid_state_change(request) person = Person(public_id=self.object.performer.pk, role=role, commitment=Commitment(role=casting, decorator_class=self.object)) profiles = self.object.get_performer_profiles() if len(profiles) > 1: person.users = [profile.user_object for profile in profiles] else: person.user = profiles[0].user_object if same_show and not same_role: person.booking_id = show.booking_id set_response = set_person(person=person) self.show_set_act_status(request, set_response) if request.POST['accepted'] != '3': self.clear_bookings(request, rehearsals) elif not same_show: self.clear_bookings(request, rehearsals, show) set_response = set_person(occurrence_id=self.new_show.pk, person=person) self.show_set_act_status(request, set_response) user_message = UserMessage.objects.get_or_create( view=self.__class__.__name__, code="ACT_ACCEPTED", defaults={ 'summary': "Act State Changed (Accept/Waitlist)", 'description': act_status_change_msg }) messages.success( request, "%s<br>Performer/Act: %s - %s<br>State: %s<br>Show: %s" % (user_message[0].description, self.object.performer.name, self.object.b_title, acceptance_states[int( request.POST['accepted'])][1], self.new_show.eventitem.child().e_title)) else: self.clear_bookings(request, rehearsals, show) user_message = UserMessage.objects.get_or_create( view=self.__class__.__name__, code="ACT_NOT_ACCEPTED", defaults={ 'summary': "Act State Changed (Not Accepted)", 'description': act_status_change_msg }) messages.success( request, "%s<br>Performer/Act: %s - %s<br>State: %s" % (user_message[0].description, self.object.performer.name, self.object.b_title, acceptance_states[int( request.POST['accepted'])][1])) return super(ActChangeStateView, self).bid_state_change(request)
def get(self, request, *args, **kwargs): eventitem_id = kwargs['eventitem_id'] schedule_items = [] personal_schedule_items = [] eventitem_view = get_event_display_info(eventitem_id) person = None if request.user.is_authenticated() and request.user.profile: person = Person( user=request.user, public_id=request.user.profile.pk, public_class="Profile") personal_schedule_items = get_schedule( request.user, labels=[ eventitem_view['event'].calendar_type, eventitem_view['event'].e_conference.conference_slug] ).schedule_items for occurrence in eventitem_view['scheduled_events']: schedule_item = { 'occurrence': occurrence, 'favorite_link': reverse( 'set_favorite', args=[occurrence.pk, 'on'], urlconf='gbe.scheduling.urls'), 'highlight': None, 'evaluate': None } if eventitem_view['event'].calendar_type == "Volunteer" or ( eventitem_view['event'].e_conference.status == "completed" ): schedule_item['favorite_link'] = None if eventitem_view['event'].calendar_type == "Conference": eval_response = get_eval_info(occurrence_id=occurrence.pk, person=person) if len(eval_response.questions) > 0: if person and len(eval_response.answers) > 0: schedule_item['evaluate'] = "disabled" else: schedule_item['evaluate'] = reverse( 'eval_event', args=[occurrence.pk, ], urlconf='gbe.scheduling.urls') for booking in personal_schedule_items: if booking.event == occurrence: schedule_item['highlight'] = booking.role.lower() if booking.role == "Interested": schedule_item['favorite_link'] = reverse( 'set_favorite', args=[occurrence.pk, 'off'], urlconf='gbe.scheduling.urls') else: schedule_item['favorite_link'] = "disabled" schedule_item['evaluate'] = None schedule_items += [schedule_item] template = 'gbe/scheduling/event_detail.tmpl' return render(request, template, {'eventitem': eventitem_view, 'show_tickets': True, 'tickets': eventitem_view['event'].get_tickets, 'user_id': request.user.id, 'schedule_items': schedule_items})
def get(self, request, *args, **kwargs): context = self.groundwork(request, args, kwargs) items = self.get_events_list_by_type() events = [] eval_occurrences = [] all_roles = [] personal_schedule_items = [] if request.user.is_authenticated and hasattr(request.user, 'profile'): person = Person(user=request.user, public_id=request.user.profile.pk, public_class="Profile") for n, m in role_options: all_roles += [m] personal_schedule_items = get_schedule( request.user, labels=[self.conference.conference_slug], roles=all_roles, ).schedule_items eval_response = get_eval_info(person=person) if len(eval_response.questions) > 0: eval_occurrences = eval_response.occurrences else: eval_occurrences = None for item in items: scheduled_events = [] presenters = [] response = get_occurrences(foreign_event_ids=[item.eventitem_id]) for occurrence in response.occurrences: (favorite_link, volunteer_link, evaluate, highlight, vol_disable_msg) = build_icon_links( occurrence, eval_occurrences, item.calendar_type, (self.conference.status == "completed"), personal_schedule_items) scheduled_events += [{ 'occurrence': occurrence, 'favorite_link': favorite_link, 'volunteer_link': volunteer_link, 'highlight': highlight, 'evaluate': evaluate, 'vol_disable_msg': vol_disable_msg, 'approval_needed': occurrence.approval_needed, }] people_response = get_bookings( [occurrence.pk], roles=["Teacher", "Moderator", "Panelist"]) for person in people_response.people: if person.public_class != "Profile": presenter = Performer.objects.get(pk=person.public_id) if presenter not in presenters: presenters += [presenter] if len(presenters) == 0 and item.calendar_type == "Conference": presenters += [item.teacher] events += [{ 'eventitem': item, 'scheduled_events': scheduled_events, 'presenters': presenters, 'detail': reverse('detail_view', urlconf='gbe.scheduling.urls', args=[item.eventitem_id]) }] context['events'] = events return render(request, self.template, context)
def LandingPageView(request, profile_id=None, historical=False): historical = "historical" in request.GET.keys() standard_context = {} standard_context['events_list'] = Event.objects.all()[:5] if (profile_id): admin_profile = validate_perms(request, ('Registrar', 'Volunteer Coordinator', 'Act Coordinator', 'Class Coordinator', 'Vendor Coordinator', 'Ticketing - Admin')) viewer_profile = get_object_or_404(Profile, pk=profile_id) admin_message = "You are viewing a user's profile, not your own." else: viewer_profile = validate_profile(request, require=False) admin_message = None template = loader.get_template('gbe/landing_page.tmpl') class_to_class_name = {Act: "Act", Class: "Class", Costume: "Costume", Vendor: "Vendor", Volunteer: "Volunteer"} class_to_view_name = {Act: 'act_review', Class: 'class_review', Costume: 'costume_review', Vendor: 'vendor_review', Volunteer: 'volunteer_review'} if viewer_profile: bids_to_review = [] person = Person( user=viewer_profile.user_object, public_id=viewer_profile.pk, public_class="Profile") for bid in viewer_profile.bids_to_review(): bid_type = class_to_class_name.get(bid.__class__, "UNKNOWN") view_name = class_to_view_name.get(bid.__class__, None) url = "" if view_name: url = reverse(view_name, urlconf='gbe.urls', args=[str(bid.id)]) bids_to_review += [{'bid': bid, 'url': url, 'action': "Review", 'bid_type': bid_type}] bookings = [] for booking in get_schedule( viewer_profile.user_object).schedule_items: gbe_event = booking.event.eventitem.child() booking_item = { 'id': booking.event.pk, 'role': booking.role, 'conference': gbe_event.e_conference, 'starttime': booking.event.starttime, 'interested': get_bookings( [booking.event.pk], roles=["Interested"]).people, 'eventitem_id': gbe_event.eventitem_id, 'title': gbe_event.e_title, } if gbe_event.calendar_type == "Conference" and ( booking.role not in ("Teacher", "Performer", "Moderator")): eval_check = get_eval_info(booking.event.pk, person) if len(eval_check.questions) > 0: if len(eval_check.answers) > 0: booking_item['evaluate'] = "disabled" else: booking_item['evaluate'] = reverse( 'eval_event', args=[booking.event.pk, ], urlconf='gbe.scheduling.urls') bookings += [booking_item] context = RequestContext( request, {'profile': viewer_profile, 'historical': historical, 'alerts': viewer_profile.alerts(historical), 'standard_context': standard_context, 'personae': viewer_profile.get_personae(), 'troupes': viewer_profile.get_troupes(), 'combos': viewer_profile.get_combos(), 'acts': viewer_profile.get_acts(historical), 'shows': viewer_profile.get_shows(), 'classes': viewer_profile.is_teaching(historical), 'proposed_classes': viewer_profile.proposed_classes(historical), 'vendors': viewer_profile.vendors(historical), 'volunteering': viewer_profile.get_volunteerbids(), 'costumes': viewer_profile.get_costumebids(historical), 'review_items': bids_to_review, 'tickets': get_purchased_tickets(viewer_profile.user_object), 'acceptance_states': acceptance_states, 'admin_message': admin_message, 'bookings': bookings, }) if not historical: user_message = UserMessage.objects.get_or_create( view="LandingPageView", code="ABOUT_INTERESTED", defaults={ 'summary': "About Interested Attendees", 'description': interested_explain_msg}) context['interested_info'] = user_message[0].description else: context = RequestContext(request, {'standard_context': standard_context}) return HttpResponse(template.render(context))
def AssignVolunteerView(request, volunteer_id): ''' Show a bid which needs to be assigned to shifts by the coordinator. To show: display useful information about the bid, If user is not a coordinator, politely decline to show anything. ''' reviewer = validate_perms(request, ('Volunteer Coordinator',)) if int(volunteer_id) == 0 and request.method == 'POST': volunteer_id = int(request.POST['volunteer']) volunteer = get_object_or_404( Volunteer, id=volunteer_id, ) if not volunteer.is_current: return HttpResponseRedirect(reverse( 'volunteer_view', urlconf='gbe.urls', args=[volunteer_id])) conference, old_bid = get_conf(volunteer) actionURL = reverse('volunteer_changestate', urlconf='gbe.urls', args=[volunteer_id]) response = get_occurrences( labels=[volunteer.b_conference.conference_slug], max_volunteer=1) show_general_status(request, response, "AssignVolunteerView") rehearsals = GenericEvent.objects.filter( type='Rehearsal Slot', e_conference=volunteer.b_conference ).values_list('eventitem_id', flat=True) sched_response = get_schedule( user=volunteer.profile.user_object, labels=[volunteer.b_conference.conference_slug, ], roles=['Volunteer', ]) show_general_status(request, sched_response, "AssignVolunteerView") booking_ids = [] for schedule_item in sched_response.schedule_items: booking_ids += [schedule_item.event.pk] conf_windows = conference.windows() volunteer_event_windows = [] volunteer_events = Event.objects.filter( e_conference=volunteer.b_conference) for event in response.occurrences: if event.foreign_event_id not in rehearsals: window = { 'occurrence': event, 'window': conf_windows.filter( day__day=event.starttime.date(), start__lte=event.starttime.time(), end__gt=event.starttime.time()).first(), 'booked': event.pk in booking_ids, 'eventitem': event.eventitem, 'staff_areas': StaffArea.objects.filter( conference=conference, slug__in=event.labels.values_list('text', flat=True)) } if hasattr(event, 'container_event'): window['parent_event'] = event.container_event.parent_event volunteer_event_windows += [window] return render( request, 'gbe/assign_volunteer.tmpl', {'volunteer': volunteer, 'interests': volunteer.interest_list, 'volunteer_event_windows': volunteer_event_windows, 'actionURL': actionURL, 'conference': conference, 'old_bid': old_bid})
def get(self, request, *args, **kwargs): self.groundwork(request, args, kwargs) viewer_profile = self.viewer_profile context = {} bids_to_review = [] person = Person(user=viewer_profile.user_object, public_id=viewer_profile.pk, public_class="Profile") for bid in viewer_profile.bids_to_review(): bids_to_review += [{ 'bid': bid, 'url': reverse('%s_review' % bid.__class__.__name__.lower(), urlconf='gbe.urls', args=[str(bid.id)]), 'action': "Review", 'bid_type': bid.__class__.__name__ }] personae, troupes = viewer_profile.get_performers(organize=True) bookings = [] booking_ids = [] manage_shows = [] shows = [] classes = [] acts = Act.objects.filter( Q(performer__in=personae) | Q(performer__in=troupes)) for booking in get_schedule(viewer_profile.user_object).schedule_items: gbe_event = booking.event.eventitem.child() booking_item = { 'id': booking.event.pk, 'role': booking.role, 'conference': gbe_event.e_conference, 'starttime': booking.event.starttime, 'interested': get_bookings([booking.event.pk], roles=["Interested"]).people, 'eventitem_id': gbe_event.eventitem_id, 'title': gbe_event.e_title, } if gbe_event.calendar_type == "Conference" and ( booking.role not in ("Teacher", "Performer", "Moderator")): eval_check = get_eval_info(booking.event.pk, person) if len(eval_check.questions) > 0: if len(eval_check.answers) > 0: booking_item['evaluate'] = "disabled" else: booking_item['evaluate'] = reverse( 'eval_event', args=[ booking.event.pk, ], urlconf='gbe.scheduling.urls') elif gbe_event.calendar_type == "Conference": classes += [booking_item] if gbe_event.e_conference.status != "completed": if gbe_event.calendar_type == "General" and (booking.commitment is not None): shows += [(gbe_event, acts.get(id=booking.commitment.class_id))] # roles assigned direct to shows if booking.role in ('Stage Manager', 'Technical Director', 'Producer'): manage_shows += [booking.event] # staff leads often work a volunteer slot in the show elif self.is_staff_lead and hasattr(booking.event, 'container_event'): parent = booking.event.container_event.parent_event if parent not in manage_shows and Show.objects.filter( eventitem_id=parent.eventitem.eventitem_id).exists( ) and parent not in manage_shows: manage_shows += [parent] if booking.event.pk not in booking_ids: bookings += [booking_item] booking_ids += [booking.event.pk] current_conf = get_current_conference() # filter for conf AFTER bookings if self.historical: acts = acts.filter(b_conference__status="completed") else: acts = acts.exclude(b_conference__status="completed") context = { 'profile': viewer_profile, 'historical': self.historical, 'alerts': viewer_profile.alerts(shows, classes), 'personae': personae, 'troupes': troupes, 'manage_shows': manage_shows, 'businesses': viewer_profile.business_set.all(), 'acts': acts, 'shows': shows, 'proposed_classes': viewer_profile.proposed_classes(self.historical), 'vendors': viewer_profile.vendors(self.historical), 'costumes': viewer_profile.get_costumebids(self.historical), 'review_items': bids_to_review, 'tickets': get_purchased_tickets(viewer_profile.user_object), 'acceptance_states': acceptance_states, 'admin_message': self.admin_message, 'bookings': bookings, 'act_paid': verify_performer_app_paid(viewer_profile.user_object.username, current_conf), 'vendor_paid': verify_vendor_app_paid(viewer_profile.user_object.username, current_conf), 'logged_in_message': UserMessage.objects.get_or_create(view="LandingPageView", code="GENERAL_MESSAGE", defaults={ 'summary': "Left hand sidebar message", 'description': '' })[0].description } if not self.historical: user_message = UserMessage.objects.get_or_create( view="LandingPageView", code="ABOUT_INTERESTED", defaults={ 'summary': "About Interested Attendees", 'description': interested_explain_msg }) right_side_msg = UserMessage.objects.get_or_create( view="LandingPageView", code="CURRENT_BID_INSTRUCTION", defaults={ 'summary': "Right Hand Sidebar - Current Bid Message", 'description': current_bid_msg }) context['interested_info'] = user_message[0].description else: right_side_msg = UserMessage.objects.get_or_create( view="LandingPageView", code="HISTORICAL_BID_INSTRUCTION", defaults={ 'summary': "Right Hand Sidebar - Historical Bid Message", 'description': historic_bid_msg }) context['right_side_intro'] = right_side_msg[0].description return render(request, 'gbe/landing_page.tmpl', context)
def get_context_data(self, request): acts = [] all_valid = True scheduling_link = '' columns = [ 'Order', 'Tech Done', 'Act', 'Performer', 'Rehearsal', 'Music', 'Action' ] conference = self.item.e_conference # Setup act pane response = get_people(foreign_event_ids=[self.item.eventitem_id], roles=["Performer"]) show_general_status(request, response, self.__class__.__name__) for performer in response.people: rehearsals = [] order = -1 act = get_object_or_404(Act, pk=performer.commitment.class_id) sched_response = get_schedule( labels=[act.b_conference.conference_slug], commitment=act) show_general_status(request, sched_response, self.__class__.__name__) for item in sched_response.schedule_items: if item.event not in rehearsals and ( GenericEvent.objects.filter( eventitem_id=item.event.eventitem.eventitem_id, type='Rehearsal Slot').exists()): rehearsals += [item.event] elif Show.objects.filter(eventitem_id=item.event.eventitem. eventitem_id).exists(): order = item.commitment.order if request.POST: form = ActScheduleBasics(request.POST, prefix=performer.booking_id) all_valid = all_valid and form.is_valid() else: form = ActScheduleBasics( prefix=performer.booking_id, initial={'order': performer.commitment.order}) rebook_form = Form() rebook_form.fields['accepted'] = ChoiceField(choices=((3, 3), ), initial=3, widget=HiddenInput()) rebook_form = make_show_casting_form(conference, rebook_form, self.item.eventitem_id, performer.commitment.role) acts += [{ 'act': act, 'rehearsals': rehearsals, 'order': order, 'rebook_form': rebook_form, 'form': form }] # Setup Volunteer pane opps = [] roles = [] for role, commit in list(role_commit_map.items()): if commit[0] > 0 and commit[0] < 4: roles += [role] opps_response = get_occurrences( labels=[conference.conference_slug, "Volunteer"], parent_event_id=self.occurrence.pk) if opps_response: show_general_status(request, opps_response, self.__class__.__name__) for opp in opps_response.occurrences: item = { 'event': opp, 'areas': [], } for area in StaffArea.objects.filter(slug__in=opp.labels, conference=conference): item['areas'] += [area] opps += [item] vol_msg = UserMessage.objects.get_or_create( view=self.__class__.__name__, code="VOLUNTEER_PANEL_INSTRUCTIONS", defaults={ 'summary': "Instructions at top of Volunteer Panel", 'description': volunteer_panel_instr }) return { 'this_show': self.item, 'email_forms': self.setup_email_forms(), 'this_occurrence': self.occurrence, 'acts': acts, 'all_valid': all_valid, 'columns': columns, 'other_shows': self.show_scope, 'conference_slugs': conference_slugs(), 'conference': conference, 'can_schedule': self.can_schedule_acts, 'can_rebook': self.can_rebook, 'can_approve_vol': self.can_approve_vol, 'can_assign_act': self.can_assign_act, 'change_acts': self.can_change_techinfo, 'opps': opps, 'role_commit_map': role_commit_map, 'visible_roles': roles, 'act_panel_instructions': UserMessage.objects.get_or_create( view=self.__class__.__name__, code="ACT_PANEL_INSTRUCTIONS", defaults={ 'summary': "Instructions at top of Act Panel", 'description': act_panel_instr })[0].description, 'volunteer_panel_instructions': vol_msg[0].description, 'vol_columns': [ 'Event', 'Area', 'Date/Time', 'Location', 'Max', 'Current', 'Volunteers' ] }