def update_occurrence(occurrence_id,
start_time=None,
max_volunteer=None,
max_commitments=None,
people=None,
roles="All",
locations=None,
approval=None,
parent_event_id=None,
labels=None):
response = get_occurrence(occurrence_id)
if response.errors:
return response
occurrence = response.occurrence
if start_time:
occurrence.starttime = start_time
if max_volunteer is not None:
occurrence.max_volunteer = max_volunteer
if max_commitments is not None:
occurrence.max_commitments = max_commitments
if approval is not None:
occurrence.approval_needed = approval
if start_time or max_volunteer or approval or max_commitments:
occurrence.save()
if locations is not None:
occurrence.set_locations(locations)
if parent_event_id is not None:
if hasattr(occurrence, 'container_event'):
occurrence.container_event.delete()
if parent_event_id > -1:
parent = get_occurrence(parent_event_id)
if parent.errors:
return parent
family = EventContainer(
child_event=response.occurrence,
parent_event=parent.occurrence)
family.save()
if labels is not None:
occurrence.eventlabel_set.all().delete()
for label in labels:
label = EventLabel(text=label, event=response.occurrence)
label.save()
warnings = []
if people is not None:
if roles == "All":
Worker.objects.filter(
allocations__event=occurrence).delete()
else:
Worker.objects.filter(allocations__event=occurrence,
role__in=roles).delete()
for person in people:
warnings += occurrence.allocate_person(
person).warnings
response.warnings = warnings
return response
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 set_person(occurrence_id=None, person=None):
occurrence = None
alloc = None
if occurrence_id:
occ_response = get_occurrence(occurrence_id)
if occ_response.errors:
return occ_response
occurrence = occ_response.occurrence
elif person and person.booking_id:
try:
alloc = ResourceAllocation.objects.get(pk=person.booking_id)
occurrence = alloc.event
except ResourceAllocation.DoesNotExist:
return BookingResponse(errors=[
Error(code="BOOKING_NOT_FOUND",
details="Booking id %s not found" % person.booking_id),
])
else:
return BookingResponse(errors=[
Error(code="OCCURRENCE_NOT_FOUND",
details="Neither booking id nor occurrence id provided")
])
if person.booking_id and not ResourceAllocation.objects.filter(
pk=person.booking_id).exists():
return BookingResponse(errors=[
Error(code="BOOKING_NOT_FOUND",
details="Booking id %s not found" % person.booking_id),
])
return occurrence.allocate_person(person)
def create_occurrence(foreign_event_id,
start_time,
max_volunteer=0,
people=[],
locations=[],
parent_event_id=None,
labels=[]):
if parent_event_id:
parent_response = get_occurrence(parent_event_id)
if parent_response.errors:
return parent_response
response = OccurrenceResponse()
response.occurrence = Event(
eventitem=EventItem.objects.get(eventitem_id=foreign_event_id),
starttime=start_time,
max_volunteer=max_volunteer)
response.occurrence.save()
if len(locations) > 0:
response.occurrence.set_locations(locations)
for person in people:
response.warnings += response.occurrence.allocate_person(
person).warnings
for label in labels:
response.occurrence.add_label(label)
if parent_event_id:
family = EventContainer(parent_event=parent_response.occurrence,
child_event=response.occurrence)
family.save()
return response
def set_eval_info(answers, occurrence_id, person):
response = get_occurrence(occurrence_id)
new_answers = []
if len(response.errors) > 0:
return EvalInfoResponse(errors=response.errors)
if response.occurrence.starttime > datetime.now(
tz=pytz.timezone('America/New_York')) - timedelta(
hours=settings.EVALUATION_WINDOW):
return EvalInfoResponse(
warnings=[Warning(
code="EVENT_IN_FUTURE",
details="The event hasn't occurred yet, and can't be rated.",
occurrence=response.occurrence)],
occurrences=[response.occurrence])
answer_giver = WorkerItem.objects.get(pk=person.public_id)
for submitted_answer in answers:
new_answer, created = answer_type_to_class[
submitted_answer.question.answer_type].objects.get_or_create(
profile=answer_giver,
event=response.occurrence,
question=submitted_answer.question,
defaults={'answer': submitted_answer.value})
new_answers += [new_answer]
return EvalInfoResponse(occurrences=[response.occurrence],
answers=new_answers)
def create_occurrence(foreign_event_id,
start_time,
max_volunteer=0,
people=[],
locations=[],
parent_event_id=None,
labels=[]):
if parent_event_id:
parent_response = get_occurrence(parent_event_id)
if parent_response.errors:
return parent_response
response = OccurrenceResponse()
response.occurrence = Event(
eventitem=EventItem.objects.get(eventitem_id=foreign_event_id),
starttime=start_time,
max_volunteer=max_volunteer)
response.occurrence.save()
if len(locations) > 0:
response.occurrence.set_locations(locations)
for person in people:
response.warnings += response.occurrence.allocate_person(
person).warnings
for label in labels:
response.occurrence.add_label(label)
if parent_event_id:
family = EventContainer(
parent_event=parent_response.occurrence,
child_event=response.occurrence)
family.save()
return response
def set_person(occurrence_id,
person):
occ_response = get_occurrence(occurrence_id)
if occ_response.errors:
return occ_response
return occ_response.occurrence.allocate_person(person)
def set_eval_info(answers, occurrence_id, person):
response = get_occurrence(occurrence_id)
new_answers = []
if len(response.errors) > 0:
return EvalInfoResponse(errors=response.errors)
if response.occurrence.starttime > datetime.now(tz=pytz.timezone(
'America/New_York')) - timedelta(hours=settings.EVALUATION_WINDOW):
return EvalInfoResponse(warnings=[
Warning(
code="EVENT_IN_FUTURE",
details="The event hasn't occurred yet, and can't be rated.",
occurrence=response.occurrence)
],
occurrences=[response.occurrence])
answer_giver = WorkerItem.objects.get(pk=person.public_id)
for submitted_answer in answers:
new_answer, created = answer_type_to_class[
submitted_answer.question.answer_type].objects.get_or_create(
profile=answer_giver,
event=response.occurrence,
question=submitted_answer.question,
defaults={'answer': submitted_answer.value})
new_answers += [new_answer]
return EvalInfoResponse(occurrences=[response.occurrence],
answers=new_answers)
def update_occurrence(occurrence_id,
start_time=None,
max_volunteer=None,
people=None,
roles="All",
locations=None):
response = get_occurrence(occurrence_id)
if response.errors:
return response
if start_time:
response.occurrence.starttime = start_time
if max_volunteer is not None:
response.occurrence.max_volunteer = max_volunteer
if start_time or max_volunteer:
response.occurrence.save()
if locations is not None:
response.occurrence.set_locations(locations)
warnings = []
if people is not None:
if roles == "All":
Worker.objects.filter(
allocations__event=response.occurrence).delete()
else:
Worker.objects.filter(allocations__event=response.occurrence,
role__in=roles).delete()
for person in people:
warnings += response.occurrence.allocate_person(
person).warnings
response.warnings = warnings
return response
def get_copy_target(self, context):
response = get_occurrence(
context['copy_mode'].cleaned_data['target_event'])
event = response.occurrence.eventitem.event
second_title = "Destination is %s: %s" % (
event.e_conference.conference_slug, event.e_title)
delta = response.occurrence.starttime.date() - self.start_day
return second_title, delta, event.e_conference
def get_copy_target(self, context):
response = get_occurrence(
context['copy_mode'].cleaned_data['target_event'])
event = response.occurrence.eventitem.event
second_title = "Destination is %s: %s" % (
event.e_conference.conference_slug,
event.e_title)
delta = response.occurrence.starttime.date() - self.start_day
return second_title, delta
def get_child_copy_settings(self, form):
response = get_occurrence(form.cleaned_data['target_event'])
target_day = ConferenceDay.objects.filter(
day=response.occurrence.starttime.date(),
conference=response.occurrence.eventitem.event.e_conference).first(
)
delta = response.occurrence.starttime.date() - self.start_day
conference = response.occurrence.eventitem.event.e_conference
new_root = response.occurrence
return (new_root, target_day, delta, conference)
def copy_events_from_form(self, request):
form = self.make_event_picker(request, timedelta(0))
new_root = None
if form.is_valid():
copied_ids = []
alt_id = None
if form.cleaned_data['copy_mode'] == "copy_children_only":
(new_root,
target_day,
delta,
conference) = self.get_child_copy_settings(form)
elif form.cleaned_data['copy_mode'] == "include_parent":
target_day = form.cleaned_data['copy_to_day']
delta = target_day.day - self.start_day
conference = form.cleaned_data['copy_to_day'].conference
new_root = self.copy_root(
request,
delta,
form.cleaned_data['copy_to_day'].conference)
if new_root and new_root.__class__.__name__ == "Event":
copied_ids += [new_root.pk]
else:
alt_id = new_root.pk
for sub_event_id in form.cleaned_data["copied_event"]:
response = get_occurrence(sub_event_id)
response = self.copy_event(
response.occurrence,
delta,
conference,
new_root)
show_scheduling_occurrence_status(
request,
response,
self.__class__.__name__)
if response.occurrence:
copied_ids += [response.occurrence.pk]
url = "%s?%s-day=%d&filter=Filter" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[conference.conference_slug]),
conference.conference_slug,
target_day.pk)
if len(copied_ids) > 0:
url += "&new=%s" % str(copied_ids)
if alt_id:
url += "&alt_id=%s" % alt_id
return HttpResponseRedirect(url)
else:
context = self.make_context(request, post=request.POST)
make_copy, context = self.validate_and_proceed(request, context)
context['second_form'] = form
return render(request, self.template, context)
def get_child_copy_settings(self, form):
response = get_occurrence(
form.cleaned_data['target_event'])
target_day = ConferenceDay.objects.filter(
day=response.occurrence.starttime.date(),
conference=response.occurrence.eventitem.event.e_conference
).first()
delta = response.occurrence.starttime.date(
) - self.start_day
conference = response.occurrence.eventitem.event.e_conference
new_root = response.occurrence
return (new_root, target_day, delta, conference)
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):
self.profile = validate_perms(request, self.permissions)
if request.GET.get('next', None):
self.redirect_to = request.GET['next']
else:
self.redirect_to = reverse('manage_event_list',
urlconf='gbe.scheduling.urls')
if "occurrence_id" in kwargs:
result = get_occurrence(int(kwargs['occurrence_id']))
if result.errors and len(result.errors) > 0:
show_general_status(request, result, self.__class__.__name__)
return HttpResponseRedirect(self.redirect_to)
else:
self.occurrence = result.occurrence
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
if self.occurrence.as_subtype.__class__.__name__ == "Class":
return HttpResponseForbidden("Class copy is not yet available")
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 copy_solo(self, request, context):
delta = None
parent_event_id = None
copy_mode = context['copy_solo_mode'].cleaned_data['copy_mode']
if copy_mode_solo_choices[2][0] in copy_mode:
target_day = context['copy_solo_mode'].cleaned_data['copy_to_day']
conference = target_day.conference
delta = target_day.day - self.start_day
if copy_mode_solo_choices[0][0] in copy_mode:
parent_event_id = context['copy_solo_mode'].cleaned_data[
'target_event']
resp = get_occurrence(
context['copy_solo_mode'].cleaned_data['target_event'])
if delta is None:
delta = resp.occurrence.starttime.date() - self.start_day
conference = resp.occurrence.eventitem.event.e_conference
labels = [
conference.conference_slug,
self.occurrence.as_subtype.calendar_type
]
if copy_mode_solo_choices[1][0] in copy_mode:
labels += [context['copy_solo_mode'].cleaned_data['area'].slug]
response = self.copy_event(
self.occurrence,
delta,
conference,
context['copy_solo_mode'].cleaned_data['room'],
labels,
parent_event_id=parent_event_id,
set_room=True)
show_scheduling_occurrence_status(request, response,
self.__class__.__name__)
if response.occurrence:
target_day = ConferenceDay.objects.filter(
day=response.occurrence.starttime.date(),
conference=response.occurrence.eventitem.event.e_conference
).first()
return HttpResponseRedirect("%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[conference.conference_slug]),
conference.conference_slug,
target_day.pk,
str([response.occurrence.pk]),
))
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 get_eval_info(occurrence_id=None, person=None, visible=True):
occurrences = []
if occurrence_id:
response = get_occurrence(occurrence_id)
if len(response.errors) > 0:
return EvalInfoResponse(errors=response.errors)
occurrences += [response.occurrence]
if response.occurrence.starttime > (
datetime.now(tz=pytz.timezone('America/New_York')) -
timedelta(hours=settings.EVALUATION_WINDOW)):
return EvalInfoResponse(warnings=[
Warning(code="EVENT_IN_FUTURE",
details="The event hasn't occurred yet, " +
"and can't be rated.",
occurrence=response.occurrence)
],
occurrences=occurrences)
if visible:
questions = EventEvalQuestion.objects.filter(visible=visible)
else:
questions = EventEvalQuestion.objects.all()
answers = []
for eval_type in [EventEvalComment, EventEvalGrade, EventEvalBoolean]:
some_answers = eval_type.objects.filter(question__in=questions)
if occurrence_id:
some_answers = some_answers.filter(event__in=occurrences)
if person:
some_answers = some_answers.filter(profile__pk=person.public_id)
answers += list(
some_answers.order_by('profile__profile__display_name',
'question__order'))
if len(occurrences) == 0:
for answer in answers:
if answer.event not in occurrences:
occurrences += [answer.event]
return EvalInfoResponse(occurrences=occurrences,
questions=questions,
answers=answers)
def create_occurrence(foreign_event_id,
start_time,
max_volunteer=0,
max_commitments=0,
people=[],
locations=[],
parent_event_id=None,
labels=[],
approval=False):
if parent_event_id:
parent_response = get_occurrence(parent_event_id)
if parent_response.errors:
return parent_response
response = OccurrenceResponse()
response.occurrence = Event(
eventitem=EventItem.objects.get(eventitem_id=foreign_event_id),
starttime=start_time,
max_volunteer=max_volunteer,
max_commitments=max_commitments,
approval_needed=approval)
response.occurrence.save()
if len(locations) > 0:
response.occurrence.set_locations(locations)
for person in people:
response.warnings += response.occurrence.allocate_person(
person).warnings
for label in labels:
label = EventLabel(text=label, event=response.occurrence)
label.save()
if parent_event_id:
family = EventContainer(parent_event=parent_response.occurrence,
child_event=response.occurrence)
family.save()
return response
def get_conflicts(conflict_occurrence_id,
user=None,
labels=[]):
response = get_occurrence(conflict_occurrence_id)
if len(response.errors) > 0:
return response
basic_filter = ResourceAllocation.objects.filter(
event__starttime__lt=response.occurrence.end_time)
sched_items = []
if len(labels) > 0:
basic_filter = basic_filter.filter(
event__eventlabel__text__in=labels)
if user:
bookable_items = user.profile.get_bookable_items()
if len(bookable_items['acts']) > 0:
for item in basic_filter.filter(
resource__actresource___item__in=bookable_items['acts']):
if check_conflict(response.occurrence, item.event) and (
item.event not in sched_items):
sched_items += [item.event]
if len(bookable_items['performers']) > 0:
for item in basic_filter.filter(
resource__worker___item__in=bookable_items['performers']):
if check_conflict(response.occurrence, item.event) and (
item.event not in sched_items):
sched_items += [item.event]
basic_filter = basic_filter.filter(
resource__worker___item=user.profile)
for item in basic_filter:
if check_conflict(response.occurrence, item.event) and (
item.event not in sched_items):
sched_items += [item.event]
response = OccurrencesResponse(
occurrences=sorted(
set(sched_items),
key=lambda sched_items: sched_items.start_time))
return response
def get_eval_info(occurrence_id=None, person=None, visible=True):
occurrences = []
if occurrence_id:
response = get_occurrence(occurrence_id)
if len(response.errors) > 0:
return EvalInfoResponse(errors=response.errors)
occurrences += [response.occurrence]
if response.occurrence.starttime > (datetime.now(
tz=pytz.timezone('America/New_York')) - timedelta(
hours=settings.EVALUATION_WINDOW)):
return EvalInfoResponse(
warnings=[Warning(
code="EVENT_IN_FUTURE",
details="The event hasn't occurred yet, " +
"and can't be rated.",
occurrence=response.occurrence)],
occurrences=occurrences)
if visible:
questions = EventEvalQuestion.objects.filter(visible=visible)
else:
questions = EventEvalQuestion.objects.all()
answers = []
for eval_type in [EventEvalComment, EventEvalGrade, EventEvalBoolean]:
some_answers = eval_type.objects.filter(question__in=questions)
if occurrence_id:
some_answers = some_answers.filter(event__in=occurrences)
if person:
some_answers = some_answers.filter(profile__pk=person.public_id)
answers += list(some_answers.order_by('profile__profile__display_name',
'question__order'))
if len(occurrences) == 0:
for answer in answers:
if answer.event not in occurrences:
occurrences += [answer.event]
return EvalInfoResponse(occurrences=occurrences,
questions=questions,
answers=answers)
def post(self, request, *args, **kwargs):
error_url = self.groundwork(request, args, kwargs)
if error_url:
return error_url
self.create = False
response = None
context = None
if ('create' in request.POST.keys()) or (
'duplicate' in request.POST.keys()):
self.create = True
if 'create' in request.POST.keys():
self.event_form = VolunteerOpportunityForm(
request.POST,
prefix='new_opp',
conference=self.conference)
else:
self.event_form = VolunteerOpportunityForm(
request.POST,
conference=self.conference)
if self.event_form.is_valid():
data = self.get_basic_form_settings()
self.event.e_conference = self.conference
self.event.save()
response = create_occurrence(
self.event.eventitem_id,
self.start_time,
self.max_volunteer,
locations=[self.room],
labels=data['labels'],
parent_event_id=self.parent_id)
else:
context = {'createform': self.event_form,
'volunteer_open': True}
return self.check_success_and_return(request,
response=response,
errorcontext=context)
elif 'edit' in request.POST.keys():
self.event = get_object_or_404(
GenericEvent,
event_id=request.POST['opp_event_id'])
self.event_form = VolunteerOpportunityForm(
request.POST,
instance=self.event)
if self.event_form.is_valid():
data = self.get_basic_form_settings()
self.event_form.save()
response = update_occurrence(
data['opp_sched_id'],
self.start_time,
self.max_volunteer,
locations=[self.room])
else:
context = {'error_opp_form': self.event_form,
'volunteer_open': True}
return self.check_success_and_return(request,
response=response,
errorcontext=context)
elif 'delete' in request.POST.keys():
opp = get_object_or_404(
GenericEvent,
event_id=request.POST['opp_event_id'])
title = opp.e_title
opp.delete()
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="DELETE_SUCCESS",
defaults={
'summary': "Volunteer Opportunity Deleted",
'description': "This volunteer opportunity was deleted."})
messages.success(
request,
'%s<br>Title: %s' % (
user_message[0].description,
title))
return HttpResponseRedirect(self.success_url)
elif 'allocate' in request.POST.keys():
response = get_occurrence(request.POST['opp_sched_id'])
return HttpResponseRedirect(
reverse('edit_volunteer',
urlconf='gbe.scheduling.urls',
args=[self.conference.conference_slug,
request.POST['opp_sched_id']]))
else:
actions = self.do_additional_actions(request)
if actions:
return actions
else:
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="UNKNOWN_ACTION",
defaults={
'summary': "Unknown Action",
'description': "This is an unknown action."})
messages.error(
request,
user_message[0].description)
return HttpResponseRedirect(self.success_url)
def get(self, request, *args, **kwargs):
if request.GET.get('next', None):
redirect_to = request.GET['next']
else:
redirect_to = reverse('home', urlconf='gbe.urls')
this_url = reverse('set_volunteer',
args=[kwargs['occurrence_id'], kwargs['state']],
urlconf='gbe.scheduling.urls')
response = check_user_and_redirect(request, this_url,
self.__class__.__name__)
if response['error_url']:
return HttpResponseRedirect(response['error_url'])
self.owner = response['owner']
occurrence_id = int(kwargs['occurrence_id'])
occ_response = get_occurrence(occurrence_id)
show_general_status(request, occ_response, self.__class__.__name__)
if occ_response.errors:
return HttpResponseRedirect(redirect_to)
volunteers = get_bookings([occurrence_id],
roles=["Volunteer", "Pending Volunteer"])
bookings = []
for person in volunteers.people:
if person.user == self.owner.user_object:
bookings += [person]
schedule_response = None
if kwargs['state'] == 'on' and len(bookings) == 0:
# if this person hasn't volunteered yet, and wants to
role = "Volunteer"
default_summary = "User has volunteered"
default_message = set_volunteer_msg
if occ_response.occurrence.approval_needed:
role = "Pending Volunteer"
default_summary = "User is pending"
default_message = set_pending_msg
person = Person(user=self.owner.user_object, role=role)
schedule_response = set_person(occurrence_id, person)
show_general_status(request, schedule_response,
self.__class__.__name__, False)
if len(schedule_response.errors) == 0 and (
schedule_response.booking_id):
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="SET_%s" % role.replace(" ", "_").upper(),
defaults={
'summary': default_summary,
'description': default_message
})
messages.success(request, user_message[0].description)
elif kwargs['state'] == 'off' and len(bookings) > 0:
# if this person has volunteered, and is withdrawing
success = True
for booking in bookings:
role = booking.role
default_summary = "User withdrew"
default_message = unset_volunteer_msg
if role == "Pending Volunteer":
default_summary = "Pending user withdrew"
default_message = unset_pending_msg
schedule_response = remove_booking(occurrence_id,
booking.booking_id)
show_general_status(request, schedule_response,
self.__class__.__name__)
if schedule_response.booking_id:
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="REMOVE_%s" % role.replace(" ", "_").upper(),
defaults={
'summary': default_summary,
'description': default_message
})
messages.success(request, user_message[0].description)
if schedule_response and schedule_response.booking_id:
email_status = send_schedule_update_mail("Volunteer", self.owner)
staff_status = send_volunteer_update_to_staff(
self.owner, self.owner, occ_response.occurrence,
kwargs['state'], schedule_response)
if (email_status or staff_status) and validate_perms(
request, 'any', require=False):
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="EMAIL_FAILURE",
defaults={
'summary': "Email Failed",
'description': volunteer_allocate_email_fail_msg
})
messages.error(request,
user_message[0].description + "status code: ")
return HttpResponseRedirect(redirect_to)
def post(self, request, *args, **kwargs):
error_url = self.groundwork(request, args, kwargs)
if error_url:
return error_url
self.create = False
response = None
context = None
if ('create' in list(request.POST.keys())) or ('duplicate' in list(
request.POST.keys())):
self.create = True
if 'create' in list(request.POST.keys()):
self.event_form = VolunteerOpportunityForm(
request.POST, prefix='new_opp', conference=self.conference)
else:
self.event_form = VolunteerOpportunityForm(
request.POST, conference=self.conference)
if self.event_form.is_valid():
data = self.get_basic_form_settings()
self.event.e_conference = self.conference
self.event.save()
response = create_occurrence(self.event.eventitem_id,
self.start_time,
self.max_volunteer,
locations=[self.room],
labels=data['labels'],
parent_event_id=self.parent_id,
approval=self.approval)
else:
context = {
'createform': self.event_form,
'volunteer_open': True
}
return self.check_success_and_return(request,
response=response,
errorcontext=context)
elif 'edit' in list(request.POST.keys()):
self.event = get_object_or_404(
GenericEvent, event_id=request.POST['opp_event_id'])
self.event_form = VolunteerOpportunityForm(request.POST,
instance=self.event)
if self.event_form.is_valid():
data = self.get_basic_form_settings()
self.event_form.save()
response = update_occurrence(data['opp_sched_id'],
self.start_time,
self.max_volunteer,
locations=[self.room],
approval=self.approval)
else:
context = {
'error_opp_form': self.event_form,
'volunteer_open': True
}
return self.check_success_and_return(request,
response=response,
errorcontext=context)
elif 'delete' in list(request.POST.keys()):
opp = get_object_or_404(GenericEvent,
event_id=request.POST['opp_event_id'])
title = opp.e_title
opp.delete()
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="DELETE_SUCCESS",
defaults={
'summary': "Volunteer Opportunity Deleted",
'description': "This volunteer opportunity was deleted."
})
messages.success(
request,
'%s<br>Title: %s' % (user_message[0].description, title))
return HttpResponseRedirect(self.success_url)
elif 'allocate' in list(request.POST.keys()):
response = get_occurrence(request.POST['opp_sched_id'])
return HttpResponseRedirect(
reverse('edit_volunteer',
urlconf='gbe.scheduling.urls',
args=[
self.conference.conference_slug,
request.POST['opp_sched_id']
]))
else:
actions = self.do_additional_actions(request)
if actions:
return actions
else:
user_message = UserMessage.objects.get_or_create(
view=self.__class__.__name__,
code="UNKNOWN_ACTION",
defaults={
'summary': "Unknown Action",
'description': "This is an unknown action."
})
messages.error(request, user_message[0].description)
return HttpResponseRedirect(self.success_url)
