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 get(self, request, *args, **kwargs):
bid_id = kwargs.get("bid_id")
self.bid = get_object_or_404(self.bid_type, id=bid_id)
redirect = self.check_bid()
if redirect:
return HttpResponseRedirect(redirect)
self.owner_profile = self.get_owner_profile()
if self.owner_profile != request.user.profile:
validate_perms(request, self.viewer_permissions, require=True)
return render(request, 'gbe/bid_view.tmpl', self.make_context())
def groundwork(self, request, args, kwargs):
object_id = kwargs['object_id']
self.get_object(request, object_id)
self.reviewer = validate_perms(request, self.reviewer_permissions)
if validate_perms(request, self.coordinator_permissions,
require=False):
self.create_action_form(self.object)
else:
self.actionform = False
self.actionURL = False
self.b_conference, self.old_bid = get_conf(self.object)
self.set_bid_eval()
def get_queryset(self):
validate_perms(self.request, 'any', require=True)
qs = Profile.objects.filter(user_object__is_active=True).exclude(
display_name='')
if self.q:
qs = qs.filter(
Q(display_name__icontains=self.q)
| Q(user_object__username__icontains=self.q)
| Q(user_object__first_name__icontains=self.q)
| Q(user_object__last_name__icontains=self.q))
return qs
def groundwork(self, request, args, kwargs):
object_id = kwargs['object_id']
self.get_object(request, object_id)
self.reviewer = validate_perms(request, self.reviewer_permissions)
if validate_perms(request,
self.coordinator_permissions,
require=False):
self.create_action_form(self.object)
else:
self.actionform = False
self.actionURL = False
self.b_conference, self.old_bid = get_conf(self.object)
self.set_bid_eval()
def make_context(self, request, errorcontext=None):
context = super(EditStaffAreaView,
self).make_context(request, errorcontext)
context['edit_title'] = 'Edit Staff Area'
context['staff_id'] = self.staff_area.pk
# if there was an error in the edit form
if 'event_form' not in context:
context['event_form'] = StaffAreaForm(instance=self.staff_area)
if validate_perms(request, ('Volunteer Coordinator', ), require=False):
volunteer_initial_info = {
'max_volunteer': self.staff_area.default_volunteers,
'location': self.staff_area.default_location
}
context.update(
self.get_manage_opportunity_forms(
volunteer_initial_info,
self.manage_vol_url,
self.conference,
request,
errorcontext=errorcontext,
labels=[
self.conference.conference_slug, self.staff_area.slug
]))
else:
context['start_open'] = True
return context
def get(self, request, *args, **kwargs):
self.profile = validate_perms(request, self.permissions)
self.groundwork(request, args, kwargs)
changed_id = None
if self.style_version is None:
if hasattr(request.user, 'userstylepreview'):
changed_id = request.user.userstylepreview.version.pk
msg = "Deactivating preview of version: " + str(
request.user.userstylepreview.version)
request.user.userstylepreview.delete()
else:
msg = "No style was currently previewed."
else:
preview = None
if hasattr(request.user, 'userstylepreview'):
preview = request.user.userstylepreview
preview.version = self.style_version
else:
preview = UserStylePreview(version=self.style_version,
previewer=request.user)
msg = "Setting preview version to: " + str(preview.version)
preview.save()
changed_id = preview.version.pk
messages.success(request, msg)
theme_list = reverse('themes_list', urlconf='gbe.themes.urls')
if changed_id is not None:
theme_list = "%s?changed_id=%d" % (theme_list, changed_id)
return HttpResponseRedirect(theme_list)
def staff_area_view(request, area_id):
'''
Generates a staff area report: volunteer opportunities scheduled,
volunteers scheduled, sorted by time/day
See ticket #250
'''
show_style = False
viewer_profile = validate_perms(request, 'any', require=True)
if 'area' in request.GET.keys():
show_style = (request.GET['area'] == "Show")
opps_response = None
area = None
opps = None
if show_style:
parent_response = get_occurrences(foreign_event_ids=[area_id])
if parent_response.occurrences:
area = parent_response.occurrences[0]
opps_response = get_occurrences(
parent_event_id=parent_response.occurrences[0].pk)
else:
area = get_object_or_404(StaffArea, pk=area_id)
opps_response = get_occurrences(labels=[
area.conference.conference_slug,
area.slug])
if opps_response:
show_general_status(request, opps_response, "staff_area")
opps = opps_response.occurrences
return render(request,
'gbe/report/staff_area_schedule.tmpl',
{'opps': opps,
'area': area})
def make_context(self, request, errorcontext=None):
context = super(EditEventView,
self).make_context(request, errorcontext)
context, initial_form_info = setup_event_management_form(
self.item.e_conference,
self.item,
self.occurrence,
context)
context['edit_title'] = self.title
context['scheduling_info'] = get_scheduling_info(self.item)
if 'worker_formset' not in context:
context['worker_formset'] = self.make_formset(
event_settings[self.item.type.lower()]['roles'])
if validate_perms(request,
('Volunteer Coordinator',), require=False):
volunteer_initial_info = initial_form_info.copy()
volunteer_initial_info.pop('occurrence_id')
context.update(self.get_manage_opportunity_forms(
volunteer_initial_info,
self.manage_vol_url,
self.conference,
request,
errorcontext=errorcontext,
occurrence_id=self.occurrence.pk))
else:
context['start_open'] = True
return context
def ReviewProposalListView(request):
'''
Show the list of class bids, review results,
and give a way to update the reviews
'''
reviewer = validate_perms(request, ('Class Coordinator',))
if request.GET and request.GET.get('conf_slug'):
conference = Conference.by_slug(request.GET['conf_slug'])
else:
conference = Conference.current_conf()
header = ClassProposal().bid_review_header
classes = ClassProposal.objects.filter(
conference=conference).order_by('type', 'title')
rows = []
for aclass in classes:
bid_row = {}
bid_row['bidder_active'] = True
bid_row['bid'] = aclass.bid_review_summary
bid_row['id'] = aclass.id
bid_row['review_url'] = reverse('proposal_publish',
urlconf='gbe.urls',
args=[aclass.id])
rows.append(bid_row)
conference_slugs = Conference.all_slugs()
return render(request,
'gbe/bid_review_list.tmpl',
{'header': header,
'rows': rows,
'conference': conference,
'conference_slugs': conference_slugs})
def ViewTroupeView(request, troupe_id=None):
'''
Show troupes to troupe members, only contact should edit.
'''
profile = validate_profile(request, require=False)
if not profile:
return HttpResponseRedirect(reverse('profile_update',
urlconf='gbe.urls') +
'?next=' +
reverse('troupe-add',
urlconf='gbe.urls'))
troupe = get_object_or_404(Troupe, resourceitem_id=troupe_id)
if not (troupe.contact.profile == profile or troupe.membership.filter(
performer_profile=profile).exists() or validate_perms(
request, ('Registrar',
'Volunteer Coordinator',
'Act Coordinator',
'Conference Coordinator',
'Vendor Coordinator',
'Ticketing - Admin'), require=False)):
raise Http404
performer_form = TroupeForm(instance=troupe,
prefix="The Troupe")
performer_form.fields['membership'] = ModelMultipleChoiceField(
queryset=troupe.membership.all())
owner = get_participant_form(
troupe.contact,
prefix='Troupe Contact')
return render(request,
'gbe/bid_view.tmpl',
{'readonlyform': [performer_form, owner]})
def get(self, request, *args, **kwargs):
self.user = validate_perms(request, self.reviewer_permissions)
self.groundwork(request, args, kwargs)
return render(
request,
self.template,
self.get_select_forms())
def groundwork(self, request, args, kwargs):
self.user = validate_perms(request, self.reviewer_permissions)
self.template = None
if "template_name" in kwargs:
template_name = kwargs.get("template_name")
# permission and syntax check
match_template_info = None
for template in get_user_email_templates(self.user):
if template_name == template['name']:
match_template_info = template
if not match_template_info:
raise Http404
try:
self.template = EmailTemplate.objects.get(
name=template_name)
except:
textcontent, htmlcontent = get_mail_content(
match_template_info['default_base'])
self.initial = {
'name': template_name,
'subject': match_template_info['default_subject'],
'html_content': htmlcontent,
'description': match_template_info['description'],
'sender': settings.DEFAULT_FROM_EMAIL}
def groundwork(self, request, args, kwargs):
self.profile = validate_perms(request, self.permissions)
self.area = get_object_or_404(StaffArea,
id=int(kwargs['staff_id']))
if self.area.conference.conferenceday_set.count() > 0:
self.start_day = self.area.conference.conferenceday_set.order_by(
"day").first().day
else:
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="NO_CONF_DAYS",
defaults={
'summary': "No Conference Days in Conference",
'description': no_conf_day_msg})
messages.error(
request,
user_message[0].description)
return HttpResponseRedirect(reverse(
'manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.area.conference.conference_slug]))
response = get_occurrences(labels=[
self.area.slug,
self.area.conference.conference_slug])
self.children = response.occurrences
show_general_status(request, response, self.__class__.__name__)
def prep_act_tech_info(request, show_id=None):
show = None
acts = []
scheduling_link = ''
if show_id:
try:
show = Show.objects.get(eventitem_id=show_id)
acts = show.scheduler_events.first().get_acts(status=3)
acts = sorted(acts, key=lambda act: act.order)
if validate_perms(request, ('Scheduling Mavens', ), require=False):
scheduling_link = reverse('schedule_acts',
urlconf='scheduler.urls',
args=[show.pk])
except:
logger.error("review_act_techinfo: Invalid show id")
pass
if show:
conference = show.e_conference
else:
conf_slug = request.GET.get('conf_slug', None)
conference = get_conference_by_slug(conf_slug)
return show, acts, conference, scheduling_link
def ReviewProfilesView(request):
admin_profile = validate_perms(request, ('Registrar',
'Volunteer Coordinator',
'Vendor Coordinator',
'Scheduling Mavens',
'Act Coordinator',
'Class Coordinator',
'Ticketing - Admin',
'Staff Lead'))
header = ['Name',
'Username',
'Last Login',
'Contact Info',
'Action']
profiles = Profile.objects.filter(user_object__is_active=True)
rows = []
for aprofile in profiles:
bid_row = {}
bid_row['profile'] = (
aprofile.display_name,
aprofile.user_object.username,
aprofile.user_object.last_login)
bid_row['contact_info'] = {
'contact_email': aprofile.user_object.email,
'purchase_email': aprofile.purchase_email,
'phone': aprofile.phone
}
bid_row['id'] = aprofile.resourceitem_id
bid_row['actions'] = [
{'url': reverse(
'admin_landing_page',
urlconf='gbe.urls',
args=[aprofile.resourceitem_id]),
'text': "View Landing Page"},
{'url': reverse('welcome_letter',
urlconf='gbe.reporting.urls',
args=[aprofile.pk]),
'text': "Welcome Letter"},
{'url': reverse(
'mail_to_individual',
urlconf='gbe.email.urls',
args=[aprofile.resourceitem_id]),
'text': "Email"}
]
if 'Registrar' in request.user.profile.privilege_groups:
bid_row['actions'] += [
{'url': reverse('admin_profile',
urlconf='gbe.urls',
args=[aprofile.resourceitem_id]),
'text': "Update"}]
bid_row['actions'] += [
{'url': reverse('delete_profile',
urlconf='gbe.urls',
args=[aprofile.resourceitem_id]),
'text': "Delete"}]
rows.append(bid_row)
return render(request, 'gbe/profile_review.tmpl',
{'header': header, 'rows': rows})
def make_context(self, request, errorcontext=None):
context = super(EditVolunteerView,
self).make_context(request, errorcontext)
context, initial_form_info = setup_event_management_form(
self.item.e_conference,
self.item,
self.occurrence,
context,
open_to_public=False)
context['association_form'] = EventAssociationForm(
initial={
'staff_area': self.area,
'parent_event': self.parent_id
})
context['edit_title'] = self.title
context['scheduling_form'].fields['approval'].widget = CheckboxInput()
if validate_perms(request, ('Volunteer Coordinator', ), require=False):
context.update(
self.get_worker_allocation_forms(errorcontext=errorcontext))
if self.request.GET.get('changed_id', None):
context['changed_id'] = int(
self.request.GET.get('changed_id', None))
else:
context['start_open'] = True
return context
def get(self, request, *args, **kwargs):
context = self.groundwork(request, args, kwargs)
if self.event_type == "show":
context['second_form'] = ShowBookingForm(
initial={'e_conference': self.conference})
else:
context['second_form'] = GenericBookingForm(
initial={
'e_conference': self.conference,
'type': self.event_type.title()
})
context['scheduling_form'] = ScheduleOccurrenceForm(
conference=self.conference,
open_to_public=True,
initial={
'duration': 1,
'max_volunteer':
event_settings[self.event_type]['max_volunteer']
})
context['worker_formset'] = self.make_formset(
event_settings[self.event_type]['roles'])
if validate_perms(request, ('Ticketing - Admin', ), require=False):
context['tickets'] = LinkBPTEventForm(
initial={
'conference': self.conference,
})
return render(request, self.template, context)
def groundwork(self, request, args, kwargs):
self.user = validate_perms(request, self.reviewer_permissions)
self.template = None
if "template_name" in kwargs:
template_name = kwargs.get("template_name")
# permission and syntax check
match_template_info = None
for template in get_user_email_templates(self.user):
if template_name == template['name']:
match_template_info = template
if not match_template_info:
raise Http404
try:
self.template = EmailTemplate.objects.get(name=template_name)
except:
textcontent, htmlcontent = get_mail_content(
match_template_info['default_base'])
self.initial = {
'name': template_name,
'subject': match_template_info['default_subject'],
'html_content': htmlcontent,
'description': match_template_info['description'],
'sender': settings.DEFAULT_FROM_EMAIL
}
def shared_groundwork(request, kwargs, permissions):
conference = None
occurrence_id = None
occurrence = None
item = None
profile = validate_perms(request, permissions)
if "conference" in kwargs:
conference = get_object_or_404(
Conference,
conference_slug=kwargs['conference'])
if "occurrence_id" in kwargs:
occurrence_id = int(kwargs['occurrence_id'])
result = get_occurrence(occurrence_id)
if result.errors and len(result.errors) > 0:
show_scheduling_occurrence_status(
request,
result,
"EditEventView")
return None
else:
occurrence = result.occurrence
item = get_object_or_404(
Event,
eventitem_id=occurrence.foreign_event_id).child()
return (profile, occurrence, item)
def groundwork(self, request):
self.reviewer = validate_perms(request, self.reviewer_permissions)
if request.GET.get('conf_slug'):
self.conference = Conference.by_slug(request.GET['conf_slug'])
else:
self.conference = Conference.current_conf()
self.conference_slugs = Conference.all_slugs()
def groundwork(self, request, args, kwargs):
self.user = validate_perms(request, self.email_permissions)
user_profile = get_object_or_404(
Profile,
resourceitem_id=kwargs.get('profile_id'))
return [(user_profile.user_object.email, "%s <%s>" % (
user_profile.display_name,
user_profile.user_object.email))]
def groundwork(self, request, args, kwargs):
self.user = validate_perms(request, self.email_permissions)
user_profile = get_object_or_404(
Profile,
resourceitem_id=kwargs.get('profile_id'))
return [(user_profile.user_object.email, "%s <%s>" % (
user_profile.display_name,
user_profile.user_object.email))]
def groundwork(self, request, args, kwargs):
context = super(StaffAreaWizardView,
self).groundwork(request, args, kwargs)
context['event_type'] = "Staff Area"
context['second_title'] = "Create Staff Area"
context['volunteer_scheduling'] = validate_perms(
request, ('Volunteer Coordinator', ), require=False)
return context
def get(self, request, *args, **kwargs):
admin_profile = validate_perms(request, self.reviewer_permissions)
troupes = Troupe.objects.filter(contact__user_object__is_active=True)
rows = []
intro = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="INTRODUCTION",
defaults={
'summary': "Top of Page Instructions",
'description': troupe_intro_msg
})
for troupe in troupes:
bid_row = {}
members = ""
for member in troupe.membership.filter(
contact__user_object__is_active=True):
members += "%s,<br>" % member.name
bid_row['profile'] = (
troupe.name, "%s<br>(<a href='%s'>%s</a>)" %
(troupe.contact.display_name,
reverse('mail_to_individual',
urlconf='gbe.email.urls',
args=[troupe.contact.resourceitem_id
]), troupe.contact.user_object.email), members)
bid_row['id'] = troupe.resourceitem_id
bid_row['actions'] = [{
'url':
reverse('troupe_view',
urlconf='gbe.urls',
args=[troupe.resourceitem_id]),
'text':
"View Troupe"
}, {
'url':
reverse('admin_landing_page',
urlconf='gbe.urls',
args=[troupe.contact.resourceitem_id]),
'text':
"View Contact Landing Page"
}, {
'url':
reverse('mail_to_individual',
urlconf='gbe.email.urls',
args=[troupe.contact.resourceitem_id]),
'text':
"Email Contact"
}]
rows.append(bid_row)
return render(
request, 'gbe/profile_review.tmpl', {
'title': "Manage Troupes",
'intro': intro[0].description,
'columns': self.header,
'rows': rows,
'order': 0,
'title': self.title
})
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 groundwork(self, request, args, kwargs):
self.profile = validate_perms(request, self.permissions)
if "conference" in kwargs:
self.conference = get_object_or_404(
Conference, conference_slug=kwargs['conference'])
context = {
'selection_form': self.get_pick_event_form(request),
'conference_slug': self.conference.conference_slug,
}
return 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 groundwork(self, request, args, kwargs):
context = super(StaffAreaWizardView,
self).groundwork(request, args, kwargs)
context['event_type'] = "Staff Area"
context['second_title'] = "Create Staff Area"
context['volunteer_scheduling'] = validate_perms(
request,
('Volunteer Coordinator',),
require=False)
return context
def staff_area_view(request, target):
'''
Generates a staff area report: volunteer opportunities scheduled,
volunteers scheduled, sorted by time/day
See ticket #250
'''
viewer_profile = validate_perms(request, (
'Act Coordinator',
'Class Coordinator',
'Costume Coordinator',
'Vendor Coordinator',
'Volunteer Coordinator',
'Tech Crew',
'Scheduling Mavens',
'Staff Lead',
'Ticketing - Admin',
'Registrar',
),
require=True)
other = "Potential"
roles = []
if 'filter' in list(request.GET.keys()) and (request.GET['filter']
== "Potential"):
other = "Committed"
for role, commit in list(role_commit_map.items()):
if commit[0] == 1 or (commit[0] > 0 and commit[0] < 4
and other == "Committed"):
roles += [role]
opps_response = None
area = None
opps = None
conference = None
edit_link = None
area = get_object_or_404(StaffArea, pk=target)
opps_response = get_occurrences(
labels=[area.conference.conference_slug, area.slug])
conference = area.conference
if area.conference.status != 'completed':
edit_link = reverse("edit_staff",
urlconf='gbe.scheduling.urls',
args=[area.pk])
if opps_response:
show_general_status(request, opps_response, "staff_area")
opps = opps_response.occurrences
return render(
request, 'gbe/report/staff_area_schedule.tmpl', {
'opps': opps,
'area': area,
'conference': conference,
'role_commit_map': role_commit_map,
'visible_roles': roles,
'other_option': other,
'edit_link': edit_link,
})
def groundwork(self, request, args, kwargs):
self.profile = validate_perms(request, ('Admins', ))
if not self.profile.user_object.is_superuser:
raise PermissionDenied
message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="CHANGE_CONF_DAY_INTRO",
defaults={
'summary': "Change Conference Day Instructions",
'description': change_day_note})
return message[0].description
def groundwork(self, request, args, kwargs):
self.historical = "historical" in list(request.GET.keys())
self.is_staff_lead = False
self.admin_message = None
if "profile_id" in kwargs:
profile_id = kwargs.get("profile_id")
self.admin_profile = validate_perms(
request, ('Registrar', 'Volunteer Coordinator',
'Act Coordinator', 'Class Coordinator',
'Vendor Coordinator', 'Ticketing - Admin'))
self.viewer_profile = get_object_or_404(Profile, pk=profile_id)
self.admin_message = "You are viewing a user's profile, " + \
"not your own."
else:
self.viewer_profile = validate_profile(request, require=False)
self.is_staff_lead = validate_perms(request, [
'Staff Lead',
],
require=False)
def groundwork(self, request, args, kwargs):
self.profile = validate_perms(request, self.permissions)
if "conference" in kwargs:
self.conference = get_object_or_404(
Conference,
conference_slug=kwargs['conference'])
context = {
'selection_form': self.get_pick_event_form(request),
'conference_slug': self.conference.conference_slug,
}
return 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 view_techinfo(request):
'''
Show the list of act tech info for all acts in a given show for a given
tech area.
export specifies the type of export, csv or view. area is the tech area
of the information being exported, audio, lighting, stage_mgmt, or all.
'''
validate_perms(request, ('Tech Crew', ))
area = request.GET.get('area', 'all')
show_id = request.GET.get('show_id', None)
area = request.GET.get('area', 'all')
show, acts, conference, scheduling_link = prep_act_tech_info(
request, show_id)
if show_id:
logger.info(area + ', ' + show_id)
header, techinfo = build_techinfo(show_id, area=area)
logger.info(techinfo)
logger.info(header)
else:
logger.info(area)
header = None
techinfo = None
return render(
request, 'gbe/report/view_techinfo.tmpl', {
'this_show': show,
'area': area,
'area_options': ['all', 'audio', 'stage_mgmt', 'lighting'],
'all_shows': Show.objects.filter(e_conference=conference),
'techinfo': techinfo,
'header': header,
'conference_slugs': conference_slugs(),
'conference': conference,
'scheduling_link': scheduling_link,
'return_link': reverse(
'view_techinfo',
urlconf='gbe.reporting.urls',
)
})
def groundwork(self, request, args, kwargs):
self.occurrence_id = int(kwargs['occurrence_id'])
self.profile = validate_perms(request, self.permissions)
response = get_occurrence(self.occurrence_id)
show_general_status(request, response, self.__class__.__name__)
if not response.occurrence:
raise Http404
self.occurrence = response.occurrence
self.start_day = self.occurrence.starttime.date()
response = get_occurrences(parent_event_id=self.occurrence_id)
self.children = response.occurrences
show_general_status(request, response, self.__class__.__name__)
def groundwork(self, request, args, kwargs):
context = super(TicketedEventWizardView,
self).groundwork(request, args, kwargs)
self.event_type = kwargs['event_type']
context['event_type'] = event_settings[self.event_type]['event_type']
context['second_title'] = event_settings[
self.event_type]['second_title']
context['tickets'] = None
context['volunteer_scheduling'] = event_settings[
self.event_type]['volunteer_scheduling'] and validate_perms(
request, ('Volunteer Coordinator', ), require=False)
return context
def groundwork(self, request, args, kwargs):
self.profile = validate_perms(request, self.permissions)
if "staff_id" in kwargs:
self.staff_area = get_object_or_404(StaffArea,
id=int(kwargs['staff_id']))
self.conference = self.staff_area.conference
self.manage_vol_url = reverse('manage_vol',
urlconf='gbe.scheduling.urls',
args=[self.staff_area.id])
self.labels = [self.staff_area.slug]
self.success_url = reverse('edit_staff',
urlconf='gbe.scheduling.urls',
args=[self.staff_area.id])
def review_act_techinfo(request, show_id=None):
'''
Show the list of act tech info for all acts in a given show
'''
validate_perms(request, ('Tech Crew',))
# using try not get_or_404 to cover the case where the show is there
# but does not have any scheduled events.
# I can still show a list of shows this way.
show, acts, conference, scheduling_link = prep_act_tech_info(
request, show_id)
return render(request,
'gbe/report/act_tech_review.tmpl',
{'this_show': show,
'acts': acts,
'all_shows': conf.Show.objects.filter(
e_conference=conference),
'conference_slugs': conference_slugs(),
'conference': conference,
'scheduling_link': scheduling_link,
'return_link': reverse('act_techinfo_review',
urlconf='gbe.reporting.urls',)})
def view_techinfo(request):
'''
Show the list of act tech info for all acts in a given show for a given
tech area.
export specifies the type of export, csv or view. area is the tech area
of the information being exported, audio, lighting, stage_mgmt, or all.
'''
validate_perms(request, ('Tech Crew',))
area = request.GET.get('area', 'all')
show_id = request.GET.get('show_id', None)
area = request.GET.get('area', 'all')
show, acts, conference, scheduling_link = prep_act_tech_info(
request, show_id)
if show_id:
logger.info(area+', '+show_id)
header, techinfo = build_techinfo(show_id, area=area)
logger.info(techinfo)
logger.info(header)
else:
logger.info(area)
header = None
techinfo = None
return render(request,
'gbe/report/view_techinfo.tmpl',
{'this_show': show,
'area': area,
'area_options': ['all', 'audio', 'stage_mgmt', 'lighting'],
'all_shows': Show.objects.filter(
e_conference=conference),
'techinfo': techinfo,
'header': header,
'conference_slugs': conference_slugs(),
'conference': conference,
'scheduling_link': scheduling_link,
'return_link': reverse('view_techinfo',
urlconf='gbe.reporting.urls',)})
def room_schedule(request, room_id=None):
viewer_profile = validate_perms(request,
'any',
require=True)
conference_slugs = conf.Conference.all_slugs()
if request.GET and request.GET.get('conf_slug'):
conference = conf.Conference.by_slug(request.GET['conf_slug'])
else:
conference = conf.Conference.current_conf()
if room_id:
rooms = [get_object_or_404(sched.LocationItem,
resourceitem_id=room_id)]
else:
rooms = sched.LocationItem.objects.all()
conf_days = conference.conferenceday_set.all()
tmp_days = []
for position in range(0, len(conf_days)):
tmp_days.append(conf_days[position].day)
conf_days = tmp_days
# rearrange the data into the format of:
# - room & date of booking
# - list of bookings
# this lets us have 1 table per day per room
room_set = []
for room in rooms:
day_events = []
current_day = None
for booking in room.get_bookings:
if not current_day:
current_day = booking.start_time.date()
if current_day != booking.start_time.date():
if current_day in conf_days:
room_set += [{'room': room,
'date': current_day,
'bookings': day_events}]
current_day = booking.start_time.date()
day_events = []
day_events += [booking]
if current_day in conf_days:
room_set += [{'room': room,
'date': current_day,
'bookings': day_events}]
return render(request, 'gbe/report/room_schedule.tmpl',
{'room_date': room_set,
'conference_slugs': conference_slugs,
'conference': conference})
def room_setup(request):
conference_slugs = conf.Conference.all_slugs()
if request.GET and request.GET.get('conf_slug'):
conference = conf.Conference.by_slug(request.GET['conf_slug'])
else:
conference = conf.Conference.current_conf()
conf_days = conference.conferenceday_set.all()
tmp_days = []
for position in range(0, len(conf_days)):
tmp_days.append(conf_days[position].day)
conf_days = tmp_days
viewer_profile = validate_perms(request, 'any', require=True)
rooms = sched.LocationItem.objects.all()
# rearrange the data into the format of:
# - room & date of booking
# - list of bookings
# this lets us have 1 table per day per room
room_set = []
for room in rooms:
day_events = []
current_day = None
for booking in room.get_bookings:
booking_class = sched.EventItem.objects.get_subclass(
eventitem_id=booking.eventitem.eventitem_id)
if not current_day:
current_day = booking.start_time.date()
if current_day != booking.start_time.date():
if (current_day in conf_days and len(day_events) > 0):
room_set += [{'room': room,
'date': current_day,
'bookings': day_events}]
current_day = booking.start_time.date()
day_events = []
if booking_class.__class__.__name__ == 'Class':
day_events += [{'event': booking,
'class': booking_class}]
if (current_day in conf_days and len(day_events) > 0):
room_set += [{'room': room,
'date': current_day,
'bookings': day_events}]
return render(request,
'gbe/report/room_setup.tmpl',
{'room_date': room_set,
'conference_slugs': conference_slugs,
'conference': conference})
def groundwork(self, request, args, kwargs):
context = super(TicketedEventWizardView,
self).groundwork(request, args, kwargs)
self.event_type = kwargs['event_type']
context['event_type'] = event_settings[
self.event_type]['event_type']
context['second_title'] = event_settings[
self.event_type]['second_title']
context['tickets'] = None
context['volunteer_scheduling'] = event_settings[
self.event_type]['volunteer_scheduling'] and validate_perms(
request,
('Volunteer Coordinator',),
require=False)
return context
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 post(self, request, *args, **kwargs):
more_view = "edit_event"
context = self.groundwork(request, args, kwargs)
if self.event_type == "show":
context['second_form'] = ShowBookingForm(request.POST)
more_view = "edit_show"
else:
context['second_form'] = GenericBookingForm(request.POST)
context['scheduling_form'] = ScheduleOccurrenceForm(
request.POST,
conference=self.conference)
context['worker_formset'] = self.make_formset(
event_settings[self.event_type]['roles'],
post=request.POST)
if validate_perms(request, ('Ticketing - Admin',), require=False):
context['tickets'] = LinkBPTEventForm(request.POST, initial={
'conference': self.conference, })
if context['second_form'].is_valid(
) and context['scheduling_form'].is_valid(
) and self.is_formset_valid(context['worker_formset']) and (
not context['tickets'] or context['tickets'].is_valid()):
new_event = context['second_form'].save(commit=False)
new_event.duration = Duration(
minutes=context['scheduling_form'].cleaned_data[
'duration']*60)
new_event.save()
response = self.book_event(context['scheduling_form'],
context['worker_formset'],
new_event)
if context['tickets']:
self.setup_ticket_links(request, new_event, context['tickets'])
success = self.finish_booking(
request,
response,
context['scheduling_form'].cleaned_data['day'].pk)
if success:
if request.POST.get(
'set_event') == 'More...':
return HttpResponseRedirect(
"%s?volunteer_open=True&rehearsal_open=True" %
reverse(more_view,
urlconf='gbe.scheduling.urls',
args=[self.conference.conference_slug,
response.occurrence.pk]))
else:
return success
return render(request, self.template, context)
def post(self, request, *args, **kwargs):
self.user = validate_perms(request, self.reviewer_permissions)
self.groundwork(request, args, kwargs)
if 'send' in request.POST.keys():
everyone = False
recipient_info = None
to_list = []
if 'everyone' in request.POST.keys():
to_list = self.get_everyone(request)
everyone = True
elif self.select_form_is_valid():
to_list, recipient_info = self.prep_email_form(request)
if len(to_list) > 0:
mail_form = self.send_mail(request, to_list)
if mail_form.is_valid():
return HttpResponseRedirect(self.url)
else:
context = {
"email_form": mail_form,
"recipient_info": [recipient_info],
"everyone": everyone}
context.update(self.get_select_forms())
return render(
request,
self.template,
context)
elif 'everyone' in request.POST.keys():
return self.filter_everyone(request)
elif ('filter' in request.POST.keys() or 'refine' in request.POST.keys(
)) and self.select_form_is_valid():
return self.filter_emails(request)
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="UNKNOWN_ACTION",
defaults={
'summary': "Unknown Request",
'description': unknown_request})
messages.error(
request,
user_message[0].description)
return render(
request,
self.template,
self.get_select_forms())
def DeleteProfileView(request, profile_id):
admin_profile = validate_perms(request, ('Registrar',))
if profile_id:
user_profile = get_object_or_404(Profile, resourceitem_id=profile_id)
return_page = HttpResponseRedirect(reverse('manage_users',
urlconf='gbe.urls'))
bookings = ResourceAllocation.objects.filter(
resource__worker___item=user_profile).count()
if (bookings >= 1) or (
user_profile.personae.count() >= 1) or (
user_profile.contact.count() >= 1) or (
user_profile.volunteering.count() >= 1) or (
user_profile.costumes.count() >= 1) or (
user_profile.vendor_set.count() >= 1) or (
user_profile.bidevaluation_set.count() >= 1) or (
user_profile.actbidevaluation_set.count() >= 1) or (
user_profile.user_object.purchaser_set.count() >= 1):
user_profile.user_object.is_active = False
user_profile.user_object.save()
admin_page = "<a href='/admin/auth/user/%d/'>User Page</a>" % (
user_profile.user_object.pk
)
user_message = UserMessage.objects.get_or_create(
view='DeleteProfileView',
code="DEACTIVATE_PROFILE_ADMIN",
defaults={
'summary': "Update Profile Success",
'description':
default_deactivate_profile_admin_msg + admin_page
})
else:
user_profile.user_object.delete()
user_message = UserMessage.objects.get_or_create(
view='DeleteProfileView',
code="DELETE_PROFILE_ADMIN",
defaults={
'summary': "Update Profile Success",
'description': default_delete_profile_admin_msg})
deletion_summary = "Removed %s<br><br>\n%s" % (
user_profile.user_object.username,
user_message[0].description)
messages.success(request, deletion_summary)
return return_page
def volunteer_type_view(request, conference_choice, volunteer_type_id):
'''
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)
vol_type = get_object_or_404(AvailableInterest, pk=volunteer_type_id)
eventitem_id_list = GenericEvent.objects.filter(
e_conference__conference_slug=conference_choice,
volunteer_type=vol_type).values_list('eventitem_id', flat=True)
collection = get_occurrences(
labels=[conference_choice, 'Volunteer'],
foreign_event_ids=eventitem_id_list)
show_general_status(request, collection, "volunteer_type")
return render(request,
'gbe/report/staff_area_schedule.tmpl',
{'opps': collection.occurrences,
'vol_type': vol_type})
def groundwork(self, request, args, kwargs):
redirect = super(
MakeVolunteerView,
self).groundwork(request, args, kwargs)
if redirect:
return redirect
if self.bid_object and (self.bid_object.profile != self.owner):
self.coordinator = validate_perms(
request,
('Volunteer Coordinator',))
self.owner = self.bid_object.profile
try:
self.windows = self.conference.windows()
self.available_interests = AvailableInterest.objects.filter(
visible=True).order_by('interest')
except:
return self.no_vol_bidding(request)
if len(self.windows) == 0 or len(self.available_interests) == 0:
return self.no_vol_bidding(request)
if not self.bid_object:
self.action = "Submission"
try:
existing_bid = self.owner.volunteering.get(
b_conference=self.conference)
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="FOUND_EXISTING_BID",
defaults={
'summary': "Existing Volunteer Offer Found",
'description': existing_volunteer_msg})
messages.success(request, user_message[0].description)
return reverse(
'volunteer_edit',
urlconf='gbe.urls',
args=[existing_bid.id])
except:
pass
def get(self, request, *args, **kwargs):
context = self.groundwork(request, args, kwargs)
if self.event_type == "show":
context['second_form'] = ShowBookingForm(
initial={'e_conference': self.conference})
else:
context['second_form'] = GenericBookingForm(
initial={'e_conference': self.conference,
'type': self.event_type.title()})
context['scheduling_form'] = ScheduleOccurrenceForm(
conference=self.conference,
open_to_public=True,
initial={'duration': 1,
'max_volunteer': event_settings[
self.event_type]['max_volunteer']})
context['worker_formset'] = self.make_formset(
event_settings[self.event_type]['roles'])
if validate_perms(request, ('Ticketing - Admin',), require=False):
context['tickets'] = LinkBPTEventForm(initial={
'conference': self.conference, })
return render(request, self.template, context)
def get(self, request, *args, **kwargs):
self.reviewer = validate_perms(request, self.reviewer_permissions)
self.user = request.user
if request.GET.get('conf_slug'):
self.conference = Conference.by_slug(request.GET['conf_slug'])
else:
self.conference = Conference.current_conf()
if request.GET.get('changed_id'):
self.changed_id = int(request.GET['changed_id'])
else:
self.changed_id = -1
try:
self.get_bid_list()
except IndexError:
return HttpResponseRedirect(reverse('home', urlconf='gbe.urls'))
self.conference_slugs = Conference.all_slugs()
return render(request, self.template,
self.get_context_dict())
def review_staff_area_view(request):
'''
Shows listing of staff area stuff for drill down
'''
viewer_profile = validate_perms(request, 'any', require=True)
if request.GET and request.GET.get('conf_slug'):
conference = Conference.by_slug(request.GET['conf_slug'])
else:
conference = Conference.current_conf()
header = ['Area', 'Leaders', 'Check Staffing']
return render(
request,
'gbe/report/staff_areas.tmpl',
{'header': header,
'areas': StaffArea.objects.filter(conference=conference),
'shows': Show.objects.filter(e_conference=conference),
'volunteer_types': AvailableInterest.objects.filter(visible=True),
'conference_slugs': conference_slugs(),
'conference': conference})
def get_nodes(self, request):
"""
populate for users based on profile.
Users must have special privileges to use this
"""
nodes = []
profile = validate_perms(request, 'any', require=False)
if profile:
privileges = set(request.user.profile.privilege_groups)
roles = profile.get_roles()
for role in ['Technical Director', 'Producer', 'Staff Lead']:
if role in roles:
privileges.add(role)
nodes.append(NavigationNode(_("Special"), "", 1))
for node in special_menu_tree:
if not privileges.isdisjoint(node['groups']):
nodes.append(NavigationNode(
title=node['title'],
url=node['url'],
id=node['id'],
parent_id=node['parent_id']))
return nodes
