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'
]
}
