def process_inputs(self, request, args, kwargs):
context = {}
self.calendar_type = None
self.conference = None
self.this_day = None
self.can_edit_show = False
if "calendar_type" in kwargs:
self.calendar_type = kwargs['calendar_type']
if self.calendar_type not in list(calendar_type_options.values()):
raise Http404
if "day" in self.request.GET:
try:
self.this_day = get_object_or_404(
ConferenceDay,
day=datetime.strptime(self.request.GET.get('day', None),
URL_DATE))
except ValueError:
raise Http404
self.conference = self.this_day.conference
elif "conference" in self.request.GET:
self.conference = get_conference_by_slug(
self.request.GET.get('conference', None))
else:
self.conference = get_current_conference()
if not self.this_day:
self.this_day = get_conference_days(
self.conference, open_to_public=True).order_by("day").first()
context = {
'calendar_type': self.calendar_type,
'conference': self.conference,
'conference_slugs': conference_slugs(),
'this_day': self.this_day,
}
if self.calendar_type == "General" and validate_perms(
request, self.show_editors, require=False):
self.can_edit_show = True
if self.this_day:
open_to_public = [True]
if self.calendar_type == "Volunteer":
open_to_public = [True, False]
if ConferenceDay.objects.filter(
day=self.this_day.day + timedelta(days=1),
open_to_public__in=open_to_public).exists():
context['next_date'] = (self.this_day.day +
timedelta(days=1)).strftime(URL_DATE)
if ConferenceDay.objects.filter(
day=self.this_day.day - timedelta(days=1),
open_to_public__in=open_to_public).exists():
context['prev_date'] = (self.this_day.day -
timedelta(days=1)).strftime(URL_DATE)
return context
def process_inputs(self, request, args, kwargs):
context = {}
self.conference = None
self.this_day = None
if "day" in self.request.GET:
self.this_day = get_object_or_404(
ConferenceDay,
day=datetime.strptime(self.request.GET.get('day', None),
URL_DATE))
self.conference = self.this_day.conference
elif "conference" in self.request.GET:
self.conference = get_conference_by_slug(
self.request.GET.get('conference', None))
else:
self.conference = get_current_conference()
# volunteer events happen on non-public days, as well, but we'll
# default to a public day to start navigation as those tend to have
# more need for help.
if not self.this_day:
self.this_day = get_conference_days(
self.conference, open_to_public=True).order_by("day").first()
instructions = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="VOLUNTEER_INSTRUCTIONS",
defaults={
'summary': "Volunteer Instructions (in header)",
'description': volunteer_instructions
})
pending_instructions = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="PENDING_INSTRUCTIONS",
defaults={
'summary': "Pending Instructions (in modal, approval needed)",
'description': pending_note
})
context = {
'conference': self.conference,
'this_day': self.this_day,
'view_header_text': instructions[0].description,
'pending_note': pending_instructions[0].description,
}
if self.this_day:
if ConferenceDay.objects.filter(day=self.this_day.day +
timedelta(days=1)).exists():
context['next_date'] = (self.this_day.day +
timedelta(days=1)).strftime(URL_DATE)
if ConferenceDay.objects.filter(day=self.this_day.day -
timedelta(days=1)).exists():
context['prev_date'] = (self.this_day.day -
timedelta(days=1)).strftime(URL_DATE)
return context
def process_inputs(self, request, args, kwargs):
context = {}
self.calendar_type = None
self.conference = None
self.this_day = None
if "calendar_type" in kwargs:
self.calendar_type = kwargs['calendar_type']
if self.calendar_type not in calendar_type_options.values():
raise Http404
if "day" in self.request.GET:
try:
self.this_day = get_object_or_404(
ConferenceDay,
day=datetime.strptime(self.request.GET.get('day', None),
URL_DATE))
except ValueError:
raise Http404
self.conference = self.this_day.conference
elif "conference" in self.request.GET:
self.conference = get_conference_by_slug(
self.request.GET.get('conference', None))
else:
self.conference = get_current_conference()
if not self.this_day:
self.this_day = get_conference_days(
self.conference,
open_to_public=True).order_by("day").first()
context = {
'calendar_type': self.calendar_type,
'conference': self.conference,
'conference_slugs': conference_slugs(),
'this_day': self.this_day,
}
if self.this_day:
open_to_public = [True]
if self.calendar_type == "Volunteer":
open_to_public = [True, False]
if ConferenceDay.objects.filter(
day=self.this_day.day+timedelta(days=1),
open_to_public__in=open_to_public).exists():
context['next_date'] = (self.this_day.day+timedelta(days=1)
).strftime(URL_DATE)
if ConferenceDay.objects.filter(
day=self.this_day.day-timedelta(days=1),
open_to_public__in=open_to_public).exists():
context['prev_date'] = (self.this_day.day-timedelta(days=1)
).strftime(URL_DATE)
return context
def __init__(self, *args, **kwargs):
open_to_public = None
if 'conference' in kwargs:
conference = kwargs.pop('conference')
else:
conference = get_current_conference()
if 'open_to_public' in kwargs:
open_to_public = kwargs.pop('open_to_public')
super(ScheduleOccurrenceForm, self).__init__(*args, **kwargs)
self.fields['day'].queryset = get_conference_days(
conference, open_to_public)
def __init__(self, *args, **kwargs):
open_to_public = None
if 'conference' in kwargs:
conference = kwargs.pop('conference')
else:
conference = get_current_conference()
if 'open_to_public' in kwargs:
open_to_public = kwargs.pop('open_to_public')
super(ScheduleOccurrenceForm, self).__init__(*args, **kwargs)
self.fields['day'].queryset = get_conference_days(
conference,
open_to_public)
def all_volunteer_view(request):
'''
Generates a staff area report: volunteer opportunities scheduled,
volunteers scheduled, sorted by time/day
See ticket #250
'''
viewer_profile = validate_perms(request, 'any', require=True)
roles = []
if request.GET and request.GET.get('conf_slug'):
conference = get_conference_by_slug(request.GET['conf_slug'])
else:
conference = get_current_conference()
for role, commit in list(role_commit_map.items()):
if commit[0] > 0 and commit[0] < 4:
roles += [role]
opps_response = None
opps = []
opps_response = get_occurrences(
labels=[conference.conference_slug, "Volunteer"])
if opps_response:
show_general_status(request, opps_response, "staff_area")
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]
return render(request,
'gbe/report/flat_volunteer_review.tmpl',
{'opps': opps,
'conference': conference,
'conference_slugs': conference_slugs(),
'role_commit_map': role_commit_map,
'visible_roles': roles,
'columns': ['Event',
'Parent',
'Area',
'Date/Time',
'Location',
'Max',
'Current',
'Volunteers']
})
def groundwork(self, request, args, kwargs):
viewer_profile = validate_perms(request, 'any', require=True)
if request.GET and request.GET.get('conf_slug'):
self.conference = get_conference_by_slug(request.GET['conf_slug'])
else:
self.conference = get_current_conference()
if "profile_id" in kwargs:
self.profiles = [
get_object_or_404(Profile, pk=kwargs['profile_id'])
]
else:
self.profiles = Profile.objects.filter(
user_object__is_active=True).select_related()
def list_reports(request):
'''
Shows listing of all reports in this area
'''
viewer_profile = validate_perms(request, 'any', require=True)
if request.GET and request.GET.get('conf_slug'):
conference = get_conference_by_slug(request.GET['conf_slug'])
else:
conference = get_current_conference()
return render(request,
'gbe/report/report_list.tmpl', {
'conference_slugs': conference_slugs(),
'conference': conference,
'return_link': reverse('report_list',
urlconf='gbe.reporting.urls')})
def groundwork(self, request, args, kwargs):
viewer_profile = validate_perms(request, 'any', require=True)
if request.GET and request.GET.get('conf_slug'):
self.conference = get_conference_by_slug(request.GET['conf_slug'])
else:
self.conference = get_current_conference()
if "profile_id" in kwargs:
self.profiles = [get_object_or_404(
Profile,
pk=kwargs['profile_id'])]
else:
self.profiles = Profile.objects.filter(
user_object__is_active=True).select_related()
def BiosTeachersView(request):
'''
Display the teachers bios. Teachers are anyone teaching,
moderating or being a panelist.
'''
conf_slug = request.GET.get('conference', None)
if not conf_slug:
conference = get_current_conference()
else:
conference = get_conference_by_slug(conf_slug)
conferences = conference_list()
performers = Performer.objects.all()
bid_classes = Class.objects.filter(
e_conference=conference,
accepted=3)
bios = []
workers, commits = get_scheduled_events_by_role(
conference,
["Teacher", "Moderator", "Panelist"])
for performer in performers:
classes = []
for worker in workers.filter(_item=performer):
for commit in commits.filter(resource=worker):
classes += [{
'role': worker.role,
'event': commit.event,
'detail_id': commit.event.eventitem.eventitem_id}]
for a_class in bid_classes.filter(teacher=performer):
if len(commits.filter(
event__eventitem__event__class=a_class)) == 0:
classes += [{
'role': "Teacher",
'event': a_class}]
if len(classes) > 0:
bios += [{'bio': performer, 'classes': classes}]
template = 'gbe/bio_list.tmpl'
context = {'bios': bios,
'bio_url': reverse('bios_teacher',
urlconf='gbe.urls'),
'title': 'Conference Bios',
'conferences': conferences}
return render(request, template, context)
def setup(self, request, args, kwargs):
validate_perms(request, ('Scheduling Mavens',))
context = {}
self.conference = None
conference_set = conference_list().order_by('-conference_slug')
if "conference_slug" in kwargs:
self.conference = get_conference_by_slug(
kwargs['conference_slug'])
else:
self.conference = get_current_conference()
day_list = []
for day in self.conference.conferenceday_set.all():
day_list += [(day.pk, day.day.strftime(DATE_FORMAT))]
select_form = SelectEventForm(request.GET,
prefix=self.conference.conference_slug)
select_form.fields['day'].choices = day_list
select_form.fields['staff_area'].queryset = StaffArea.objects.filter(
conference=self.conference
).order_by("slug")
context = {
'conference': self.conference,
'conference_slugs': [
conf.conference_slug for conf in conference_set],
'selection_form': select_form,
'other_forms': [],
}
if 'new' in request.GET.keys():
context['success_occurrences'] = eval(request.GET['new'])
if 'alt_id' in request.GET.keys():
context['alt_id'] = long(request.GET['alt_id'])
for conf in conference_set:
if self.conference != conf:
hidden_form = HiddenSelectEventForm(
request.GET,
prefix=conf.conference_slug)
conf_day_list = []
for day in conf.conferenceday_set.all():
conf_day_list += [(day.pk, day.day.strftime(DATE_FORMAT))]
hidden_form.fields['day'].choices = conf_day_list
context['other_forms'] += [hidden_form]
return context
def BiosTeachersView(request):
'''
Display the teachers bios. Teachers are anyone teaching,
moderating or being a panelist.
'''
conf_slug = request.GET.get('conference', None)
if not conf_slug:
conference = get_current_conference()
else:
conference = get_conference_by_slug(conf_slug)
conferences = conference_list()
performers = Performer.objects.all()
bid_classes = Class.objects.filter(e_conference=conference, accepted=3)
bios = []
workers, commits = get_scheduled_events_by_role(
conference, ["Teacher", "Moderator", "Panelist"])
for performer in performers:
classes = []
for worker in workers.filter(_item=performer):
for commit in commits.filter(resource=worker):
classes += [{
'role': worker.role,
'event': commit.event,
'detail_id': commit.event.eventitem.eventitem_id
}]
for a_class in bid_classes.filter(teacher=performer):
if len(commits.filter(
event__eventitem__event__class=a_class)) == 0:
classes += [{'role': "Teacher", 'event': a_class}]
if len(classes) > 0:
bios += [{'bio': performer, 'classes': classes}]
template = 'gbe/bio_list.tmpl'
context = {
'bios': bios,
'bio_url': reverse('bios_teacher', urlconf='gbe.urls'),
'title': 'Conference Bios',
'conferences': conferences
}
return render(request, template, context)
def groundwork(self, request, args, kwargs):
validate_perms(request, ('Scheduling Mavens', 'Admins'))
context = {}
self.conference = None
conference_set = conference_list().order_by('-conference_slug')
if "conference_slug" in kwargs:
self.conference = get_conference_by_slug(kwargs['conference_slug'])
else:
self.conference = get_current_conference()
day_list = []
for day in self.conference.conferenceday_set.all():
day_list += [(day.pk, day.day.strftime(GBE_DATE_FORMAT))]
select_form = SelectEventForm(request.GET,
prefix=self.conference.conference_slug)
select_form.fields['day'].choices = day_list
select_form.fields['staff_area'].queryset = StaffArea.objects.filter(
conference=self.conference).order_by("slug")
context = {
'conference': self.conference,
'conference_slugs':
[conf.conference_slug for conf in conference_set],
'selection_form': select_form,
'other_forms': [],
}
if 'new' in list(request.GET.keys()):
context['success_occurrences'] = eval(request.GET['new'])
if 'alt_id' in list(request.GET.keys()):
context['alt_id'] = int(request.GET['alt_id'])
for conf in conference_set:
if self.conference != conf:
hidden_form = HiddenSelectEventForm(
request.GET, prefix=conf.conference_slug)
conf_day_list = []
for day in conf.conferenceday_set.all():
conf_day_list += [(day.pk,
day.day.strftime(GBE_DATE_FORMAT))]
hidden_form.fields['day'].choices = conf_day_list
context['other_forms'] += [hidden_form]
return context
def setup(self, request, args, kwargs):
context = {}
if "event_type" in kwargs:
self.event_type = kwargs['event_type']
if self.event_type.lower() not in list_titles:
raise Http404
if "conference" in self.request.GET:
self.conference = get_conference_by_slug(
self.request.GET.get('conference', None))
else:
self.conference = get_current_conference()
if not self.conference:
raise Http404
context = {
'conf_slug': self.conference.conference_slug,
'conference_slugs': conference_slugs(),
'title': list_titles.get(self.event_type.lower(), ""),
'view_header_text': list_text.get(self.event_type.lower(), ""),
}
return context
def setup(self, request, args, kwargs):
context = {}
if "event_type" in kwargs:
self.event_type = kwargs['event_type']
if self.event_type.lower() not in list_titles:
raise Http404
if "conference" in self.request.GET:
self.conference = get_conference_by_slug(
self.request.GET.get('conference', None))
else:
self.conference = get_current_conference()
if not self.conference:
raise Http404
context = {
'conf_slug': self.conference.conference_slug,
'conference_slugs': conference_slugs(),
'title': list_titles.get(self.event_type.lower(), ""),
'view_header_text': list_text.get(self.event_type.lower(), ""),
}
return context
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 eval_view(request, occurrence_id=None):
details = None
reviewer = validate_perms(request, ('Class Coordinator', ))
if request.GET and request.GET.get('conf_slug'):
conference = get_conference_by_slug(request.GET['conf_slug'])
else:
conference = get_current_conference()
if occurrence_id:
detail_response = get_eval_info(occurrence_id=int(occurrence_id))
show_general_status(request, detail_response, "EvaluationDetailView")
if detail_response.occurrences and len(
detail_response.occurrences) > 0:
detail_response.answers.sort(
key=lambda answer: (answer.profile.profile.display_name,
answer.question.order))
details = {
'occurrence': detail_response.occurrences[0],
'title': detail_response.occurrences[
0].eventitem.event.e_title,
'description': detail_response.occurrences[
0].eventitem.event.e_description,
'questions': detail_response.questions,
'evaluations': detail_response.answers,
}
response = get_eval_summary(
labels=[conference.conference_slug, "Conference"])
header = ['Class',
'Teacher(s)',
'Time',
'# Interested',
'# Evaluations']
for question in response.questions:
header += [question.question]
header += ['Actions']
display_list = []
summary_view_data = {}
events = Class.objects.filter(e_conference=conference)
for occurrence in response.occurrences:
class_event = events.get(
eventitem_id=occurrence.eventitem.eventitem_id)
teachers = []
interested = []
for person in occurrence.people:
if person.role == "Interested":
interested += [person]
elif person.role in ("Teacher", "Moderator"):
teachers += [Performer.objects.get(pk=person.public_id)]
display_item = {
'id': occurrence.id,
'eventitem_id': class_event.eventitem_id,
'sort_start': occurrence.start_time,
'start': occurrence.start_time.strftime(DATETIME_FORMAT),
'title': class_event.e_title,
'teachers': teachers,
'interested': len(interested),
'eval_count': response.count.get(occurrence.pk, 0),
'detail_link': reverse(
'evaluation_detail',
urlconf='gbe.reporting.urls',
args=[occurrence.id])}
display_list += [display_item]
summary_view_data[int(occurrence.id)] = {}
for question in response.questions:
for item in response.summaries[question.pk]:
summary_view_data[int(item['event'])][int(question.pk)] = item[
'summary']
display_list.sort(key=lambda k: k['sort_start'])
user_message = UserMessage.objects.get_or_create(
view="InterestView",
code="ABOUT_EVAL_REPORT",
defaults={
'summary': "About Evaluation Report",
'description': eval_report_explain_msg})
return render(request,
'gbe/report/evals.tmpl',
{'header': header,
'classes': display_list,
'questions': response.questions,
'summaries': summary_view_data,
'conference_slugs': conference_slugs(),
'conference': conference,
'about': user_message[0].description,
'details': details})
def interest_view(request):
viewer_profile = validate_perms(request, 'any', require=True)
if request.GET and request.GET.get('conf_slug'):
conference = get_conference_by_slug(request.GET['conf_slug'])
else:
conference = get_current_conference()
response = get_occurrences(
labels=[conference.conference_slug, "Conference"])
header = ['Class',
'Teacher',
'Location',
'Max attendees',
'Style',
'Interested',
'Action']
display_list = []
events = Class.objects.filter(e_conference=conference)
for occurrence in response.occurrences:
class_event = events.get(
eventitem_id=occurrence.eventitem.eventitem_id)
teachers = []
interested = []
for person in occurrence.people:
if person.role == "Interested":
interested += [person]
elif person.role in ("Teacher", "Moderator"):
teachers += [Performer.objects.get(pk=person.public_id)]
display_item = {
'id': occurrence.id,
'sort_start': occurrence.start_time,
'start': occurrence.start_time.strftime(DATETIME_FORMAT),
'title': class_event.e_title,
'location': occurrence.location,
'teachers': teachers,
'eventitem_id': class_event.eventitem_id,
'interested': interested,
'type': class_event.type,
'maximum_enrollment': class_event.maximum_enrollment,
'detail_link': reverse(
'detail_view',
urlconf='gbe.scheduling.urls',
args=[class_event.eventitem_id])}
display_list += [display_item]
display_list.sort(key=lambda k: k['sort_start'])
user_message = UserMessage.objects.get_or_create(
view="InterestView",
code="ABOUT_INTERESTED",
defaults={
'summary': "About Interested Attendee Report",
'description': interested_report_explain_msg})
return render(request,
'gbe/report/interest.tmpl',
{'header': header,
'classes': display_list,
'conference_slugs': conference_slugs(),
'conference': conference,
'about': user_message[0].description})
def env_stuff(request, conference_choice=None):
'''
Generates an envelope-stuffing report.
'''
reviewer = validate_perms(request, ('Registrar',))
if conference_choice:
conference = get_conference_by_slug(conference_choice)
else:
conference = get_current_conference()
people = conf.Profile.objects.filter(user_object__is_active=True)
acts = conf.Act.objects.filter(
accepted=3,
b_conference=conference)
tickets = tix.Transaction.objects.filter(
ticket_item__bpt_event__conference=conference)
roles = sched.Worker.objects.filter(
Q(allocations__event__eventitem__event__e_conference=conference))
commits = sched.ResourceAllocation.objects.filter(
Q(event__eventitem__event__e_conference=conference))
header = ['Badge Name',
'First',
'Last',
'Tickets',
'Ticket format',
'Personae',
'Staff Lead',
'Volunteering',
'Presenter',
'Show']
person_details = []
for person in people:
ticket_list = ""
staff_lead_list = ""
volunteer_list = ""
class_list = ""
personae_list = ""
show_list = ""
ticket_names = ""
for ticket in tickets.filter(
purchaser__matched_to_user=person.user_object):
ticket_list += str(ticket.ticket_item.bpt_event.ticket_style)+", "
ticket_names += ticket.ticket_item.title+", "
for lead in roles.filter(role="Staff Lead", _item=person):
for commit in commits.filter(resource=lead):
staff_lead_list += str(commit.event.eventitem)+', '
for volunteer in roles.filter(role="Volunteer", _item=person):
for commit in commits.filter(resource=volunteer):
volunteer_list += str(commit.event.eventitem)+', '
for performer in person.get_performers():
personae_list += str(performer) + ', '
for teacher in roles.filter((Q(role="Teacher") |
Q(role="Moderator") |
Q(role="Panelist")) &
Q(_item=performer)):
for commit in commits.filter(resource=teacher):
class_list += (teacher.role +
': ' +
str(commit.event.eventitem) +
', ')
for act in acts.filter(performer=performer):
for commit in commits.filter(resource__actresource___item=act):
show_list += str(commit.event.eventitem)+', '
person_details.append(
[person.get_badge_name().encode('utf-8').strip(),
person.user_object.first_name.encode('utf-8').strip(),
person.user_object.last_name.encode('utf-8').strip(),
ticket_names, ticket_list,
personae_list,
staff_lead_list,
volunteer_list,
class_list,
show_list])
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=env_stuff.csv'
writer = csv.writer(response)
writer.writerow(header)
for row in person_details:
writer.writerow(row)
return response
def interest_view(request):
viewer_profile = validate_perms(request, 'any', require=True)
if request.GET and request.GET.get('conf_slug'):
conference = get_conference_by_slug(request.GET['conf_slug'])
else:
conference = get_current_conference()
response = get_occurrences(
labels=[conference.conference_slug, "Conference"])
header = [
'Class', 'Teacher', 'Location', 'Max attendees', 'Style', 'Interested',
'Action'
]
display_list = []
events = Class.objects.filter(e_conference=conference)
for occurrence in response.occurrences:
class_event = events.get(
eventitem_id=occurrence.eventitem.eventitem_id)
teachers = []
interested = []
for person in occurrence.people:
if person.role == "Interested":
interested += [person]
elif person.role in ("Teacher", "Moderator"):
teachers += [Performer.objects.get(pk=person.public_id)]
display_item = {
'id':
occurrence.id,
'title':
class_event.e_title,
'location':
occurrence.location,
'teachers':
teachers,
'eventitem_id':
class_event.eventitem_id,
'interested':
interested,
'type':
class_event.type,
'maximum_enrollment':
class_event.maximum_enrollment,
'detail_link':
reverse('detail_view',
urlconf='gbe.scheduling.urls',
args=[class_event.eventitem_id])
}
display_list += [display_item]
user_message = UserMessage.objects.get_or_create(
view="InterestView",
code="ABOUT_INTERESTED",
defaults={
'summary': "About Interested Attendee Report",
'description': interested_report_explain_msg
})
return render(
request, 'gbe/report/interest.tmpl', {
'columns': header,
'classes': display_list,
'conference_slugs': conference_slugs(),
'conference': conference,
'about': user_message[0].description
})
def get(self, request):
conference = get_current_conference()
badged_usernames = []
badged_purchases = Transaction.objects.filter(
ticket_item__ticketing_event__conference=conference).exclude(
ticket_item__ticketingeligibilitycondition__checklistitem__badge_title__isnull=True
).order_by('ticket_item')
header = ['First',
'Last',
'username',
'Badge Name',
'Badge Type',
'Ticket Purchased',
'Date']
badge_info = []
# now build content - the order of loops is specific here,
# we need ALL transactions, if they are limbo, then the purchaser
# should have a BPT first/last name
for badge in badged_purchases:
buyer = badge.purchaser.matched_to_user
badged_usernames += [buyer.username]
if hasattr(buyer, 'profile') and len(
buyer.profile.get_badge_name()) > 0:
badge_name = buyer.profile.get_badge_name()
else:
badge_name = badge.purchaser.first_name
for condition in badge.ticket_item.ticketingeligibilitycondition_set.exclude(
checklistitem__badge_title__isnull=True):
badge_info.append(
[badge.purchaser.first_name,
badge.purchaser.last_name,
buyer.username,
str(badge_name),
condition.checklistitem.badge_title,
badge.ticket_item.title,
badge.import_date])
role_conditions = RoleEligibilityCondition.objects.exclude(
checklistitem__badge_title__isnull=True)
title_to_badge = {}
if role_conditions.count() > 0:
for role_cond in role_conditions:
title_to_badge[
role_cond.role] = role_cond.checklistitem.badge_title
roles = role_conditions.values_list('role', flat=True).distinct()
response = get_people(labels=[conference.conference_slug],
roles=roles)
for person in response.people:
if person.user.username not in badged_usernames:
badge_info.append(
[person.user.first_name,
person.user.last_name,
person.user.username,
person.user.profile.get_badge_name(),
title_to_badge[person.role],
"Role Condition: %s" % person.role,
"N/A"])
badged_usernames += [person.user.username]
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=print_badges.csv'
writer = csv.writer(response)
writer.writerow(header)
for row in badge_info:
writer.writerow(row)
return response
def eval_view(request, occurrence_id=None):
details = None
reviewer = validate_perms(request, ('Class Coordinator', ))
conference = None
if request.GET and request.GET.get('conf_slug'):
conference = get_conference_by_slug(request.GET['conf_slug'])
if occurrence_id and not conference:
detail_response = get_eval_info(occurrence_id=int(occurrence_id))
show_general_status(request, detail_response, "EvaluationDetailView")
if detail_response.occurrences and len(
detail_response.occurrences) > 0:
detail_response.answers.sort(key=lambda answer: (
answer.profile.profile.display_name, answer.question.order))
details = {
'occurrence': detail_response.occurrences[0],
'title':
detail_response.occurrences[0].eventitem.event.e_title,
'description':
detail_response.occurrences[0].eventitem.event.e_description,
'questions': detail_response.questions,
'evaluations': detail_response.answers,
}
if not conference:
conference = detail_response.occurrences[
0].eventitem.event.e_conference
if not conference:
conference = get_current_conference()
response = get_eval_summary(
labels=[conference.conference_slug, "Conference"])
display_list = []
summary_view_data = {}
events = Class.objects.filter(e_conference=conference)
for occurrence in response.occurrences:
class_event = events.get(
eventitem_id=occurrence.eventitem.eventitem_id)
teachers = []
interested = []
for person in occurrence.people:
if person.role == "Interested":
interested += [person]
elif person.role in ("Teacher", "Moderator"):
teachers += [Performer.objects.get(pk=person.public_id)]
display_item = {
'id':
occurrence.id,
'eventitem_id':
class_event.eventitem_id,
'start':
occurrence.start_time.strftime(GBE_TABLE_FORMAT),
'title':
class_event.e_title,
'teachers':
teachers,
'interested':
len(interested),
'eval_count':
response.count.get(occurrence.pk, 0),
'detail_link':
reverse('evaluation_detail',
urlconf='gbe.reporting.urls',
args=[occurrence.id])
}
display_list += [display_item]
summary_view_data[int(occurrence.id)] = {}
for question in response.questions:
for item in response.summaries[question.pk]:
summary_view_data[int(item['event'])][int(
question.pk)] = item['summary']
user_message = UserMessage.objects.get_or_create(
view="InterestView",
code="ABOUT_EVAL_REPORT",
defaults={
'summary': "About Evaluation Report",
'description': eval_report_explain_msg
})
return render(
request, 'gbe/report/evals.tmpl', {
'columns':
['Class', 'Teacher(s)', 'Time', '# Interested', '# Evaluations'],
'vertical_columns':
response.questions.values_list('question', flat=True),
'last_columns': ['Actions'],
'classes':
display_list,
'questions':
response.questions,
'summaries':
summary_view_data,
'conference_slugs':
conference_slugs(),
'conference':
conference,
'about':
user_message[0].description,
'details':
details
})
def transactions(request):
'''
Represents the view for working with ticket items. This will have a
list of current ticket items, and the ability to synch them.
'''
validate_perms(request, ('Ticketing - Transactions', ))
conference_choice = request.GET.get('conference', None)
if conference_choice:
conference = get_conference_by_slug(conference_choice)
else:
conference = get_current_conference()
view_format = request.GET.get('format', 'ticket')
changed_id = int(request.GET.get('changed_id', -1))
intro = UserMessage.objects.get_or_create(view="ViewTransactions",
code="INTRO_MESSAGE",
defaults={
'summary':
"Introduction Message",
'description':
intro_transaction_message
})
count = -1
error = ''
if ('Sync' in request.POST):
msgs = process_eb_purchases()
for msg, is_success in msgs:
if is_success:
messages.success(request, msg)
else:
messages.error(request, msg)
count = process_bpt_order_list()
success_msg = UserMessage.objects.get_or_create(
view="ViewTransactions",
code="IMPORT_MESSAGE",
defaults={
'summary': "Import BPT Transactions Message",
'description': import_transaction_message
})
messages.success(
request, "%s Transactions imported: %s - BPT" %
(success_msg[0].description, count))
user_editor = validate_perms(request, ('Registrar', ), require=False)
context = {
'conference_slugs': conference_slugs(),
'conference': conference,
'changed_id': changed_id,
'error': error,
'intro': intro[0].description,
'can_edit': user_editor,
'view_format': view_format
}
if view_format == "ticket":
context['transactions'] = Transaction.objects.filter(
ticket_item__ticketing_event__conference=conference).order_by(
'ticket_item__ticketing_event', 'ticket_item__title',
'purchaser')
else:
context['users'] = User.objects.filter(
purchaser__transaction__ticket_item__ticketing_event__conference=
conference).distinct().order_by('email')
return render(request, r'ticketing/transactions.tmpl', context)
def ticket_items(request, conference_choice=None):
'''
Represents the view for working with ticket items. This will have a
list of current ticket items, and the ability to synch them.
'''
validate_perms(request, ('Ticketing - Admin', ))
if 'Import' in request.POST:
msgs = import_ticket_items()
for msg, is_success in msgs:
if is_success:
messages.success(request, msg)
else:
messages.error(request, msg)
conference_choice = request.GET.get('conference', None)
if conference_choice:
events = TicketingEvents.objects.filter(
conference__conference_slug=conference_choice).order_by('title')
conference = get_conference_by_slug(conference_choice)
else:
events = TicketingEvents.objects.exclude(
conference__status='completed').order_by('title')
conference = get_current_conference()
if conference:
conference_choice = conference.conference_slug
intro = UserMessage.objects.get_or_create(view="ViewTicketItems",
code="INTRO_MESSAGE",
defaults={
'summary':
"Introduction Message",
'description':
intro_ticket_message
})
check_intro = UserMessage.objects.get_or_create(
view="CheckTicketEventItems",
code="INTRO_MESSAGE",
defaults={
'summary': "Introduction Message",
'description': intro_ticket_assign_message
})
gbe_events = get_ticketable_gbe_events(conference_choice)
context = {
'intro':
intro[0].description,
'act_pay_form':
get_ticket_form("Act", conference),
'vendor_pay_form':
get_ticket_form("Vendor", conference),
'act_fees':
events.filter(act_submission_event=True),
'vendor_fees':
events.filter(vendor_submission_event=True),
'open_panel':
request.GET.get('open_panel', ""),
'updated_tickets':
eval(request.GET.get('updated_tickets', '[]')),
'updated_events':
eval(request.GET.get('updated_events', '[]')),
'events':
events.filter(act_submission_event=False,
vendor_submission_event=False),
'conference_slugs':
conference_slugs(),
'conference':
conference,
'check_intro':
check_intro[0].description,
'gbe_events':
gbe_events
}
return render(request, r'ticketing/ticket_items.tmpl', context)
