def VersionEvent(request, pk):
# dictionary for initial data with
# field names as keys
context = {}
# fetch the object related to passed id
obj = get_object_or_404(Event, pk=pk)
#obj.photo.delete()
#obj.photo.open(mode='rb')
# pass the object as instance in form
form = EventForm(request.POST or None, instance=obj)
# save the data from the form and
# redirect to detail_view
if form.is_valid():
obj.pk = int(round(time.time() * 1000))
#form.photo = request.POST.get('photo', False)
#form.photo = request.FILES['photo']
form.instance.creator = request.user
form.instance.record_status = "Created"
form.save()
return HttpResponseRedirect(reverse("events:all"))
else:
# add form dictionary to context
context["form"] = form
return render(request, "events/event_form.html", context)
def event_update(request, event_id):
event_obj = get_object_or_404(Event, pk=event_id)
if not (request.user.role == 'ADMIN' or request.user.is_superuser
or event_obj.created_by == request.user
or request.user in event_obj.assigned_to.all()):
raise PermissionDenied
if request.method == 'GET':
context = {}
context["event_obj"] = event_obj
context["form"] = EventForm(instance=event_obj,
request_user=request.user)
selected_recurring_days = Event.objects.filter(
name=event_obj.name).values_list('date_of_meeting', flat=True)
selected_recurring_days = [
day.strftime('%A') for day in selected_recurring_days
]
context['selected_recurring_days'] = selected_recurring_days
return render(request, 'event_create.html', context)
if request.method == 'POST':
form = EventForm(request.POST,
instance=event_obj,
request_user=request.user)
if form.is_valid():
start_date = form.cleaned_data.get('start_date')
end_date = form.cleaned_data.get('end_date')
# recurring_days
# recurring_days = request.POST.getlist('days')
if form.cleaned_data.get('event_type') == 'Non-Recurring':
event = form.save(commit=False)
event.date_of_meeting = start_date
# event.created_by = request.user
event.save()
form.save_m2m()
send_email.delay(event.id,
domain=request.get_host(),
protocol=request.scheme)
if form.cleaned_data.get('event_type') == 'Recurring':
event = form.save(commit=False)
event.save()
form.save_m2m()
send_email.delay(event.id,
domain=request.get_host(),
protocol=request.scheme)
# event.contacts.add(*request.POST.getlist('contacts'))
# event.assigned_to.add(*request.POST.getlist('assigned_to'))
return JsonResponse({
'error': False,
'success_url': reverse('events:events_list')
})
else:
return JsonResponse({
'error': True,
'errors': form.errors,
})
def edit_event(request, id):
if request.method == 'POST':
event = get_object_or_404(Event, id=id)
form = EventForm(request.POST, instance=event)
if form.is_valid():
form.save(commit=False)
event.save()
return HttpResponseRedirect(event.get_absolute_url())
else:
event = get_object_or_404(Event, id=id)
form = EventForm(instance=event)
return render_to_response('events/new_event.html', {'form': form, 'object': event}, context_instance=RequestContext(request))
def event_update(request, pk, template_name="events/event_form.html"):
if request.user.is_superuser:
event = get_object_or_404(Event, pk=pk)
else:
event = get_object_or_404(Event, pk=pk)
form = EventForm(request.POST or None, instance=event)
if form.is_valid():
form.save()
return redirect(f"/events/{pk}")
return render(request, template_name, {"form": form})
def add(request):
if request.method == 'GET':
form = EventForm()
return render(request, 'add.html', {
'form': form,
})
else:
form = EventForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect('/manage')
else:
return HttpResponse("not added event")
def event_create(request):
if request.method == 'POST':
eventform = EventForm(request.POST)
if eventform.is_valid():
eventform.save()
else:
eventform = EventForm()
print eventform
return render_to_response('events/event-create.html',
{'eventform': eventform},
context_instance=RequestContext(request)
)
def createEvent(request):
if request.method == 'POST':
form = EventForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect('/events')
else:
return render(request, 'newEvent.html', {'form': form})
else:
form = EventForm()
args = {'form': form}
return render(request, "newEvent.html", args)
def list_all_events_view(request):
''' A list view of all events. Part of archives. '''
page_name = "Archives - All Events"
profile = UserProfile.objects.get(user=request.user)
event_form = EventForm(
request.POST if "post_event" in request.POST else None,
profile=profile,
)
if event_form.is_valid():
event_form.save()
return HttpResponseRedirect(reverse('events:all'))
# a pseudo-dictionary, actually a list with items of form (event, ongoing,
# rsvpd, rsvp_form, already_past), where ongoing is a boolean of whether the
# event is currently ongoing, rsvpd is a boolean of whether the user has
# rsvp'd to the event
events_dict = list()
for event in Event.objects.all():
rsvp_form = None
if event.end_time > now():
rsvp_form = RsvpForm(
request.POST if "rsvp-{0}".format(event.pk) in request.POST else None,
instance=event,
profile=profile,
)
if rsvp_form.is_valid():
rsvpd = rsvp_form.save()
if rsvpd:
message = MESSAGES['RSVP_ADD'].format(event=event.title)
else:
message = MESSAGES['RSVP_REMOVE'].format(event=event.title)
messages.add_message(request, messages.SUCCESS, message)
return HttpResponseRedirect(reverse('events:all'))
ongoing = event.start_time <= now() and event.end_time >= now()
rsvpd = profile in event.rsvps.all()
events_dict.append(
(event, ongoing, rsvpd, rsvp_form)
)
if request.method == "POST":
messages.add_message(request, messages.ERROR, MESSAGES["EVENT_ERROR"])
return render_to_response('list_events.html', {
'page_name': page_name,
'events_dict': events_dict,
'now': now(),
'event_form': event_form,
}, context_instance=RequestContext(request))
def list_all_events_view(request):
''' A list view of all events. Part of archives. '''
page_name = "Archives - All Events"
profile = UserProfile.objects.get(user=request.user)
event_form = EventForm(
request.POST if "post_event" in request.POST else None,
profile=profile,
)
if event_form.is_valid():
event_form.save()
return HttpResponseRedirect(reverse('events:all'))
# a pseudo-dictionary, actually a list with items of form (event, ongoing,
# rsvpd, rsvp_form, already_past), where ongoing is a boolean of whether the
# event is currently ongoing, rsvpd is a boolean of whether the user has
# rsvp'd to the event
events_dict = list()
for event in Event.objects.all():
rsvp_form = None
if event.end_time > now():
rsvp_form = RsvpForm(
request.POST
if "rsvp-{0}".format(event.pk) in request.POST else None,
instance=event,
profile=profile,
)
if rsvp_form.is_valid():
rsvpd = rsvp_form.save()
if rsvpd:
message = MESSAGES['RSVP_ADD'].format(event=event.title)
else:
message = MESSAGES['RSVP_REMOVE'].format(event=event.title)
messages.add_message(request, messages.SUCCESS, message)
return HttpResponseRedirect(reverse('events:all'))
ongoing = event.start_time <= now() and event.end_time >= now()
rsvpd = profile in event.rsvps.all()
events_dict.append((event, ongoing, rsvpd, rsvp_form))
if request.method == "POST":
messages.add_message(request, messages.ERROR, MESSAGES["EVENT_ERROR"])
return render_to_response('list_events.html', {
'page_name': page_name,
'events_dict': events_dict,
'now': now(),
'event_form': event_form,
},
context_instance=RequestContext(request))
def event_edit(request, year, pk):
fair = get_object_or_404(Fair, year=year)
event = get_object_or_404(Event, pk=pk, fair=fair)
participants = Participant.objects.filter(
event=event).select_related('user_s__profile').all()
signup_questions = event.signupquestion_set.all()
react_props = {
'questions': [
serializers.signup_question(question)
for question in signup_questions
],
'question_types':
dict(SignupQuestion.QUESTION_TYPES)
}
print(request.FILES)
form = EventForm(request.POST or None,
request.FILES or None,
instance=event)
users = [
recruitment_application.user
for recruitment_application in RecruitmentApplication.objects.filter(
status='accepted', recruitment_period__fair=event.fair).order_by(
'user__first_name', 'user__last_name')
]
form.fields['contact_person'].choices = [('', '---------')] + [
(user.pk, user.get_full_name())
for user in users if user.has_perm('companies.base')
]
if request.POST and form.is_valid():
form.save()
questions_data = json.loads(request.POST['questions'])
save_questions(questions_data, event)
return HttpResponse(status=204)
return render(
request, 'events/event_edit.html', {
'fair': fair,
'event': event,
'participants': participants,
'questions': signup_questions,
'form': form,
'react_props': json.dumps(react_props)
})
def addEvent(request):
if request.method == 'POST':
event_form = EventForm(request.POST)
if event_form.is_valid():
event_form.save()
# messages.success(request, _('Your profile was successfully updated!'))
return redirect('event-list')
else:
pass
# messages.error(request, _('Please correct the error below.'))
else:
event_form = EventForm()
return render(request, 'addevent.html', {'event_form': event_form})
def post(self, request):
# Temporary part of the method to create tickets for test purposes
if 'test_baseticket' in request.POST:
response = create_test_baseticket()
return response
event_form = EventForm(request.POST)
base_ticket_price_form = BaseTicketPriceForm(request.POST)
upload_form = UploadBaseTicketNew(request.POST, request.FILES)
if not(event_form.is_valid() and base_ticket_price_form.is_valid() and upload_form.is_valid()):
return render(request, self.template_name,
{'upload_form': upload_form, 'event_form': event_form,
'base_ticket_price_form': base_ticket_price_form, 'pdf_exists': 'false'})
# if the forms were valid
pdf_file = request.FILES['pdf_file']
price = request.POST.get('price')
pdf_object = ProcessBaseTicket(pdf_file)
if not pdf_object.successful:
messages.add_message(request, messages.ERROR, pdf_object.message)
return render(request, self.template_name,
{'upload_form': upload_form, 'event_form': event_form,
'base_ticket_price_form': base_ticket_price_form, 'pdf_exists': 'false'})
event = event_form.save()
self.create_base_ticket(pdf_object, event, price)
messages.add_message(request, messages.SUCCESS, message_text.event_creation_successful)
return redirect('buy_ticket:available_tickets', event.id)
def edit_event_view(request, event_pk):
''' The view to edit an event. '''
page_name = "Edit Event"
profile = UserProfile.objects.get(user=request.user)
event = get_object_or_404(Event, pk=event_pk)
if event.owner != profile and not request.user.is_superuser:
return HttpResponseRedirect(
reverse('events:view', kwargs={"event_pk": event_pk}), )
event_form = EventForm(
request.POST or None,
profile=profile,
instance=event,
)
if event_form.is_valid():
event = event_form.save()
messages.add_message(
request,
messages.SUCCESS,
MESSAGES['EVENT_UPDATED'].format(event=event.title),
)
return HttpResponseRedirect(
reverse('events:view', kwargs={"event_pk": event_pk}), )
return render_to_response('edit_event.html', {
'page_name': page_name,
'event_form': event_form,
},
context_instance=RequestContext(request))
def create(request):
form = EventForm(request.POST or None)
if form.is_valid():
event = form.save(commit=False)
event.creator = request.user
g_d = None
for word in event.description.split():
try:
g_d = parse(word, fuzzy=True)
break
except :
continue
event.start_date = g_d
event.save()
#request.user.message_set.create(message="Event posted successfully.")
if 'next' in request.POST:
next = request.POST['next']
else:
next = reverse('ev_tonight')
return HttpResponseRedirect(next)
else:
return render_to_response(
'event/create.html',
{'form':form},
context_instance = RequestContext(request)
)
def create(request):
form = EventForm(request.POST or None)
if form.is_valid():
event = form.save(commit=False)
event.creator = request.user
guessed_date = None
for word in event.description.split():
try:
guessed_date = parse(word)
break
except ValueError:
continue
event.start_date = guessed_date
event.save()
messages.success(request, "Your event was posted")
if 'next' in request.POST:
next = request.POST['next']
else:
next = reverse('ev_tonight')
return HttpResponseRedirect(next)
return render_to_response(
'events/create.html',
{'form':form},
context_instance = RequestContext(request)
)
def create(request):
form = EventForm(request.POST or None)
if form.is_valid():
event = form.save(commit=False)
event.creator = request.user
guessed_date = None
for word in event.description.split():
try:
guessed_date = parse(word)
break
except ValueError:
pass
event.start_date = guessed_date
event.save()
messages.success(request, 'Your event was posted')
if 'next' in request.POST:
next = request.POST['next']
else:
next = reverse('ev_tonight')
return HttpResponseRedirect(next)
return render_to_response(
'events/create.html',
RequestContext(request, {'form':form})
)
def edit(request, id):
instance = get(Event, pk=id)
after_add = request.GET.get('after_add', None)
pricing = instance.pricing_set.all()
if request.method == 'POST':
form = EventForm(request.POST, instance = instance)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('events'))
else:
form = EventForm(instance = instance)
return render_to_response('event_edit.html', locals())
def change(request, id):
# visibility check
event = get_object_or_404(Event, pk=id)
parent = helpers.get_obj(ct=event.content_type, id=event.object_id)
if not helpers.is_visible(request.user, parent):
return render_to_response('denied.html',
context_instance=RequestContext(request))
if request.method == 'POST':
#request.POST.update( { 'owner':request.user.id, 'object_id':id,
# 'content_type':ct.id, 'content_obj': obj, } )
form = EventForm(request.POST, instance=event)
if form.is_valid():
ev = form.save()
return HttpResponseRedirect(ev.get_absolute_url())
else:
form = EventForm(instance=event)
context = {
'form': form,
'object': parent,
'content_type': event.content_type
}
context.update(locals())
return render_to_response('events/events_add.html', context,\
context_instance = RequestContext(request))
def edit_event(request, id):
if request.method == 'POST':
event = get_object_or_404(Event, id=id)
form = EventForm(request.POST, instance=event)
if form.is_valid():
form.save(commit=False)
event.save()
return HttpResponseRedirect(event.get_absolute_url())
else:
event = get_object_or_404(Event, id=id)
form = EventForm(instance=event)
return render_to_response('events/new_event.html', {
'form': form,
'object': event
},
context_instance=RequestContext(request))
def edit_event_view(request, event_pk):
''' The view to edit an event. '''
page_name = "Edit Event"
profile = UserProfile.objects.get(user=request.user)
event = get_object_or_404(Event, pk=event_pk)
if event.owner != profile and not request.user.is_superuser:
return HttpResponseRedirect(
reverse('events:view', kwargs={"event_pk": event_pk}),
)
event_form = EventForm(
request.POST or None,
profile=profile,
instance=event,
)
if event_form.is_valid():
event = event_form.save()
messages.add_message(
request, messages.SUCCESS,
MESSAGES['EVENT_UPDATED'].format(event=event.title),
)
return HttpResponseRedirect(
reverse('events:view', kwargs={"event_pk": event_pk}),
)
return render_to_response('edit_event.html', {
'page_name': page_name,
'event_form': event_form,
}, context_instance=RequestContext(request))
def add(request, app_label, model_name, id):
''' Tag an event to another model object '''
try:
ct = ContentType.objects.get(\
app_label = app_label,
model = model_name)
obj = ct.get_object_for_this_type( id=id )
except:
return HttpResponseNotFound()
if request.method == 'POST':
#request.POST.update( { 'owner':request.user.id, 'object_id':id,
# 'content_type':ct.id, 'content_obj': obj, } )
form = EventForm(request.POST)
if form.is_valid():
ev = form.save(commit=False)
ev.owner = request.user
ev.object_id = obj.id
ev.content_type = ct
ev.save()
return HttpResponseRedirect(ev.get_absolute_url())
else:
form = EventForm()
context = { 'form':form, 'object':obj, 'content_type':ct, }
context.update(locals())
return render_to_response('events/events_add.html', context,\
context_instance = RequestContext(request))
def user_account(request):
username = request.user
user = User.objects.get(username = username)
if request.method == 'POST':
form = EventForm(request.POST, request.FILES)
if form.is_valid():
new_event = form.save(commit=False)
new_event.author = request.user
new_event.event_time = timezone.now()
new_event.save()
return HttpResponseRedirect(request.path)
else:
form = EventForm()
user_events = Event.objects.filter(author = user).order_by("-event_time")
page = request.GET.get('page', 1)
paginator = Paginator(user_events, 10)
try:
event_list = paginator.page(page)
except PageNotAnInteger:
event_list = paginator.page(1)
except EmptyPage:
event_list = paginator.page(paginator.num_pages)
followers = Follower.objects.filter(follower_for = request.user)
context = {'user': user, 'form':form, 'user_events': event_list, 'followers': followers}
return render(request, 'account/account.html', context)
def add_event(request):
if request.method == 'GET':
event_list = Event.objects.all()
return render(request, 'admin/event-add.html',
{'event_list': event_list})
validate_event = EventForm(request.POST)
errors = {}
if validate_event.is_valid():
if validate_event.cleaned_data[
'end_date'] and validate_event.cleaned_data['start_date']:
if validate_event.cleaned_data[
'start_date'] > validate_event.cleaned_data['end_date']:
errors[
'date_err'] = 'Start Date should not greater than End Date'
return JsonResponse(errors)
if 'image' not in request.FILES:
errors['image'] = 'Please upload Image'
return JsonResponse(errors)
new_event = validate_event.save(commit=False)
new_event.image = request.FILES['image']
new_event.save()
data = {"data": 'event created successfully', "error": False}
return JsonResponse(data)
for k in validate_event.errors:
errors[k] = validate_event.errors[k][0]
if 'image' not in request.FILES:
errors['image'] = 'Please upload Image'
return JsonResponse(errors)
def event_form(request):
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
hour = form['hour'].value()
minute = form['minute'].value()
meridiem = form['meridiem'].value()
if meridiem == 'PM' and not int('0' + hour) == 12:
hour = int('0' + hour) + 12
hour = str(hour)
elif meridiem == 'AM' and int('0' + hour) == 12:
hour = int('0' + hour) - 12
hour = str(hour)
age_requirement = form['age_requirement'].value()
age = form['age'].value()
if age_requirement == 'Must be older than' or age_requirement == 'Must be younger than':
age_requirement = str(age_requirement + " " + str(age) +
" year(s) old")
else:
age_requirement = str(age_requirement)
event = form.save(commit=False)
start_time = str(hour + ':' + minute + " " + meridiem)
event.start_time = start_time
event.age_requirement = age_requirement
event.user_id = request.user.pk
event.save()
messages.add_message(request,
messages.INFO,
'Event successfully created!',
extra_tags='alert-success')
return HttpResponseRedirect('/events/' + str(event.id))
else:
form = EventForm()
return render(request, 'events/event.html', {'form': form})
def editEvent(request,eventid):
eventid = int(eventid)
event = Event.objects.get(id=eventid)
originaltags = event.tags
if request.user.id == event.user.id :
if request.method == "GET" :
mlogger.debug("the person who posted the event is editing")
form = EventForm(instance=event,initial={'tags':' '.join(event.tags.values_list('name',flat=True))},user=request.user)
return render_to_response('events/create_event.html',{'form':form,'editmode':True},RequestContext(request))
elif request.method == "POST":
form = EventForm(request.POST,instance=event,user=request.user)
if form.is_valid() :
newevent = form.save(commit=False)
newevent.save()
removeUserTagWeights(originaltags,request.user,settings.CONTRIBUTION_WEIGHT)
newevent.tags = form.cleaned_data['tags']
assignUserTagWeights(newevent.tags,request.user,settings.CONTRIBUTION_WEIGHT)
if event.sendemail is not None :
emaillist = event.sendemail.getEmailList(request.institute)
deliverEmail('event_created_subject.html','event_created.html',{'institute':request.institute,'event':event,'edit':True,'site':settings.SITE_URL},emaillist)
create_message(request,"Successfuly edited the event")
return HttpResponseRedirect(reverse('agendaviewurl'))
else:
return render_to_response('events/create_event.html',{'form':form,'editmode':True},RequestContext(request))
else :
create_message(request,"You are not authorized to edit this event")
return HttpResponseRedirect(reverse('agendaviewurl'))
def event_new(request, year):
fair = get_object_or_404(Fair, year=year)
react_props = {'question_types': dict(SignupQuestion.QUESTION_TYPES)}
form = EventForm(request.POST or None)
users = [
recruitment_application.user
for recruitment_application in RecruitmentApplication.objects.filter(
status='accepted', recruitment_period__fair=fair).order_by(
'user__first_name', 'user__last_name')
]
form.fields['contact_person'].choices = [('', '---------')] + [
(user.pk, user.get_full_name())
for user in users if user.has_perm('companies.base')
]
if request.POST and form.is_valid():
event = form.save()
questions_data = json.loads(request.POST['questions'])
save_questions(questions_data, event)
return HttpResponse(status=200)
return render(request, 'events/event_new.html', {
'fair': fair,
'form': form,
'react_props': react_props
})
def update(request):
if request.method == 'GET':
event = Event.objects.get(pk=request.GET['id'])
form = EventForm(instance=event)
return render(request, 'update.html', {
'form': form,
'id': event.id,
})
else:
instance = Event.objects.get(pk=request.POST['id'])
form = EventForm(request.POST, instance=instance)
if form.is_valid():
form.save()
return redirect('/event/view/?id=' + request.POST['id'])
else:
return HttpResponse("could not update event")
def add(request):
if request.method == "GET":
form = EventForm()
elif request.method == "POST":
form = EventForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('events.views.index'))
c = RequestContext(request)
c.update({
'form': form,
})
t = loader.get_template('events/add.html')
return HttpResponse(t.render(c))
def add(request):
if request.method == "GET":
form = EventForm()
elif request.method == "POST":
form = EventForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('events.views.index'))
c = RequestContext(request)
c.update({
'form': form,
})
t = loader.get_template('events/add.html')
return HttpResponse(t.render(c))
def events_instance_edit(request, pk):
event = Event.objects.get(pk=pk)
if request.is_ajax():
render_target = '_form.html'
else:
render_target = 'edit.html'
if request.method == 'POST':
form = EventForm(request.POST, instance=event)
if form.is_valid():
form.save(commit=False)
return redirect(event)
else:
form = EventForm(instance=event)
return render_to_response('events/%s' % render_target,
{'object': event,
'form': form,
'editing': True},
context_instance=RequestContext(request))
def event_update(request,event_id):
#embed()
#was in sample but caused crash
event = Event.objects.get(id=event_id)
if event.owner == request.user:
if request.method=="POST":
form = EventForm(request.POST, instance=event)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('event_profile',kwargs={'event_id':event_id}))
else:
return HttpResponseRedirect('/')
else:
return HttpResponse('You are not the owner of this event')
form = EventForm(instance=event)
return render(request,'events/event_update.html',{
'form':form
})
def event_create(request, template_name="events/event_form.html"):
form = EventForm(request.POST or None)
if form.is_valid():
event = form.save(commit=False)
event.user = request.user
event.save()
return redirect("events:event_list")
return render(request, template_name, {"form": form})
def add(request):
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
event = form.save()
return HttpResponseRedirect(reverse('event-edit', args=[event.id])+'?after_add=1')
else:
form = EventForm()
return render_to_response('event_add.html', locals())
def list_events_view(request):
''' A list view of upcoming events. '''
page_name = "Upcoming Events"
profile = UserProfile.objects.get(user=request.user)
event_form = EventForm(
request.POST if 'post_event' in request.POST else None,
profile=profile,
)
now = datetime.datetime.utcnow().replace(tzinfo=utc)
if event_form.is_valid():
event_form.save()
return HttpResponseRedirect(reverse('events:list'))
# a pseudo-dictionary, actually a list with items of form (event, ongoing,
# rsvpd, rsvp_form), where ongoing is a boolean of whether the event is
# currently ongoing, rsvpd is a boolean of whether the user has rsvp'd to
# the event
events_dict = list()
for event in Event.objects.filter(end_time__gte=now):
rsvp_form = RsvpForm(
request.POST if "rsvp-{0}".format(event.pk) in request.POST else None,
instance=event,
profile=profile,
)
if rsvp_form.is_valid():
rsvpd = rsvp_form.save()
if rsvpd:
message = MESSAGES['RSVP_ADD'].format(event=event.title)
else:
message = MESSAGES['RSVP_REMOVE'].format(event=event.title)
messages.add_message(request, messages.SUCCESS, message)
return HttpResponseRedirect(reverse('events:list'))
ongoing = ((event.start_time <= now) and (event.end_time >= now))
rsvpd = (profile in event.rsvps.all())
events_dict.append((event, ongoing, rsvpd, rsvp_form))
return render_to_response('list_events.html', {
'page_name': page_name,
'events_dict': events_dict,
'now': now,
'event_form': event_form,
}, context_instance=RequestContext(request))
def create_event(request):
"""
Creates an event.
"""
form = EventForm()
if request.method == "POST":
form = EventForm(request.POST,request.FILES)
if form.is_valid():
event = form.save()
return HttpResponseRedirect(reverse("event",args=(event.pk,)))
return render_to_response("events/event_form.html",{"form":form},context_instance=RequestContext(request))
def edit(request, object_id):
try:
event = Event.objects.get(pk=object_id)
except Event.DoesNotExist:
raise Http404()
if request.method == "GET":
form = EventForm(instance=event)
elif request.method == "POST":
form = EventForm(request.POST, instance=event)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('events.views.index'))
c = RequestContext(request)
c.update({
'form': form,
})
return render_to_response('events/add.html', context_instance=c)
def edit(request, object_id):
try:
event = Event.objects.get(pk=object_id)
except Event.DoesNotExist:
raise Http404()
if request.method == "GET":
form = EventForm(instance=event)
elif request.method == "POST":
form = EventForm(request.POST, instance=event)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('events.views.index'))
c = RequestContext(request)
c.update({
'form': form,
})
return render_to_response('events/add.html', context_instance=c)
def new_event(request):
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
event = form.save(commit=False)
event.user = request.user
event.save()
return HttpResponseRedirect('/events')
else:
event = Event()
form = EventForm(instance=event)
return render_to_response('events/new_event.html', {'form': form}, context_instance=RequestContext(request))
def update_event(request, pk):
event = Event.objects.get(pk=pk)
eventForm = EventForm(request.POST or None, instance=event)
race_list = event.get_races()
created = request.GET.get('created')
# if form sent
if request.method == 'POST':
if eventForm.is_valid():
eventForm.save()
if not event.event_mod_source:
# creation
messages.success(request, (
"L'événement {0} a bien été créé et sera publié "
"après validation par nos services".format(event.name)
))
else:
# update
messages.success(request, (
"L'événement {0} a bien été modifié et sera publié "
"après validation par nos services".format(event.event_mod_source.name)
))
return HttpResponseRedirect(reverse('list_race'))
# if form init
else:
if event.validated:
cloned_event = event.clone()
print("event cloned")
return HttpResponseRedirect(reverse('update_event', kwargs={'pk': cloned_event.pk}) + '?created=True')
return render(request, 'events/event_edit.html', {'eventForm': eventForm,
'pk': pk,
'race_list': race_list,
'created': created or False,
})
def new_event(request):
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
event = form.save(commit=False)
event.user = request.user
event.save()
return HttpResponseRedirect('/events')
else:
event = Event()
form = EventForm(instance=event)
return render_to_response('events/new_event.html', {'form': form},
context_instance=RequestContext(request))
def event_form(request):
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
event = form.save(commit=False)
event.user_id = request.user.pk
event.save()
messages.add_message(request, messages.INFO, 'Event successfully created!', extra_tags='alert-success')
return HttpResponseRedirect('/events/' + str(event.id))
else:
form = EventForm()
return render(request, 'events/event.html', {'form': form})
def post(self, request, **kwargs):
event_id = kwargs.get('event_id')
obj = 'create'
errors = {}
status_code = 201
obj = 'edit'
if event_id is not None:
try:
event = get_object_or_404(Event, pk=event_id)
form = EventForm(request.POST, instance=event)
event_data = form.instance.to_dict()
except Http404:
event_data = {}
status_code = 404
errors = {'message': 'could not find event', 'code': status_code}
return JsonResponse({
'object': obj,
'url': request.get_full_path(),
'data': [event_data],
'errors': [errors],
}, status=status_code)
else:
obj = 'create'
form = EventForm(request.POST)
if form.is_valid():
form.save()
event_data = form.instance.to_dict()
else:
errors = form.errors.as_json()
status_code = 400
return JsonResponse({
'object': obj,
'url': request.get_full_path(),
'data': [event_data],
'errors': [errors],
}, status=status_code)
def create(request):
"""
Renders a form for creating a new ``Event`` instance, validates against that
form, and creates the new instances.
"""
form = EventForm(request.POST or None)
if form.is_valid():
event = form.save(commit=False)
event.creator = request.user
guessed_date = None
# Ransack the description for possible datetime objects. If we find one
# then we set start_date as that found datetime.
for word in event.description.split():
try:
guessed_date = parse(word)
break
except ValueError:
continue
event.start_date = guessed_date
event.save()
if 'next' in request.POST:
next = request.POST['next']
else:
next = reverse('ev_tonight')
if request.is_ajax():
# If the request is AJAX, then render the created event and don't
# create messages for the user.
try:
Attendance.objects.get(event=event, user=request.user)
attending = True
except Attendance.DoesNotExist:
attending = False
return render_to_response('events/event.html', {'event': event,
'request': request, 'attending': attending,
'authenticated': True, 'event_num': 1, 'next': next})
else:
# If the request is not AJAX, then create messages for the user and
# redirect them to the next page.
request.user.message_set.create(
message=_('Your event was posted.'))
return HttpResponseRedirect(next)
if request.is_ajax():
raise Http404
return render_to_response(
'events/create.html',
{'form': form},
context_instance = RequestContext(request)
)
def add(request):
if not request.user.is_staff:
return HttpResponseForbidden()
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
# create and save new model
event = form.save()
return HttpResponseRedirect('/')
else:
form = EventForm()
return render(request, 'events/add.html',
{
'form': form,
})
def events_new(request):
if request.is_ajax():
render_target = '_form.html'
else:
render_target = 'new.html'
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
event = form.save(commit=False)
event.host = request.user
event.save()
return redirect(event)
else:
form = EventForm(initial=request.GET.dict())
return render_to_response('events/%s' % render_target,
{'form': form, 'editing': False},
context_instance=RequestContext(request))
def event_form(request, id=None):
if id:
instance = get_object_or_404(Event, id=id)
else:
instance = None
if request.method == 'POST':
form = EventForm(data=request.POST, instance=instance)
if form.is_valid():
event = form.save(commit=False)
event.user = request.user
event.save()
return HttpResponseRedirect(reverse('event_index'))
else:
form = EventForm(instance=instance)
return render_to_response('events/form.html',
{'form': form},
context_instance=RequestContext(request))
def add(request, app_label, model_name, id):
''' Tag an event to another model object '''
try:
ct = ContentType.objects.get(\
app_label = app_label,
model = model_name)
obj = ct.get_object_for_this_type( id=id )
except:
return HttpResponseNotFound()
# visibility check
if not helpers.is_visible(request.user, obj):
return render_to_response('denied.html', context_instance=RequestContext(request))
if request.method == 'POST':
#request.POST.update( { 'owner':request.user.id, 'object_id':id,
# 'content_type':ct.id, 'content_obj': obj, } )
form = EventForm(request.POST)
if form.is_valid():
ev = form.save(commit=False)
ev.owner = request.user
ev.object_id = obj.id
ev.content_type = ct
ev.save()
#AFK edits
#create and link ChampInfo object if one doesn't already exist
if form.cleaned_data["champable"]:
print "CHAMPCHAMPCHAMPCHAMPCHAMPCHAMPCHAMPCHAMPCHAMPCHAMPCHAMPable"
if ChampInfo.objects.exists_by_event(event=ev) == False:
ChampInfo.new(ev) #create a new ChampInfo object linked to an empty values owner
print "|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
return HttpResponseRedirect(ev.get_absolute_url())
else:
form = EventForm()
context = { 'form':form, 'object':obj, 'content_type':ct, }
context.update(locals())
return render_to_response('events/events_add.html', context,\
context_instance = RequestContext(request))
def event_edit(request, event: Event):
"""
Edit an existing event by primary key
"""
if not event.cast.is_manager(request.user):
return HttpResponseForbidden()
if request.method == 'POST':
form = EventForm(request.POST, instance=event)
if form.is_valid():
event = form.save()
messages.success(request, f'"{event.name}" has been updated')
return redirect('event_detail', pk=event.pk)
else:
form = EventForm(instance=event)
return render(request, 'events/event_edit.html', {
'form': form,
'form_title': 'Edit Event',
})
def new_event(request):
registered = False
if request.method == 'POST':
event = Event.objects.create(leader=request.user)
event_form = EventForm(request.POST or None, instance=event)
if event_form.is_valid():
event = event_form.save()
registered = True
else:
print(event_form.errors)
else:
event_form = EventForm()
return render(
request, 'event/new_event.html', {
'event_form': event_form,
'registered': registered,
'request_user': request.user
})
def create_events(request):
template_name = "events/form.html"
context = {}
if request.method == "POST":
form = EventForm(request.POST or None)
if form.is_valid():
c = form.save(commit=False)
# 2020-06-04 14:26
# c.start_time = datetime.fromtimestamp(form.cleaned_data['start_time'])
# c.end_time = datetime.strptime(form.cleaned_data['end_time'])
c.creator = request.user.member
c.save()
channel = Channel.objects.create(name="{c.name} Channel", event=c)
channel.users.add(c.creator.user)
return redirect('events:user-events')
else:
form = EventForm()
context["form"] = form
return render(request, template_name, context)
def add(request, app_label, model_name, id):
''' Tag an event to another model object '''
try:
ct = ContentType.objects.get(\
app_label = app_label,
model = model_name)
obj = ct.get_object_for_this_type(id=id)
except:
return HttpResponseNotFound()
# visibility check
if not helpers.is_visible(request.user, obj):
return render_to_response('denied.html',
context_instance=RequestContext(request))
if request.method == 'POST':
#request.POST.update( { 'owner':request.user.id, 'object_id':id,
# 'content_type':ct.id, 'content_obj': obj, } )
form = EventForm(request.POST)
if form.is_valid():
ev = form.save(commit=False)
ev.owner = request.user
ev.object_id = obj.id
ev.content_type = ct
ev.save()
return HttpResponseRedirect(ev.get_absolute_url())
else:
form = EventForm()
context = {
'form': form,
'object': obj,
'content_type': ct,
}
context.update(locals())
return render_to_response('events/events_add.html', context,\
context_instance = RequestContext(request))
def create_event(request, course_id):
if request.method == 'POST':
variables = _course_context(request, course_id)
c = Course.objects.get(id=course_id)
e = Event()
e.creator = request.user
form = EventForm(request.POST, request.FILES, instance=e)
if form.is_valid():
e = form.save()
c.add_event(e)
e.join_event(request.user.id)
c.save()
wallPost = ConversationPost(creator=request.user, wall=c.wall, message="", post_type='E', event=e)
wallPost.save()
notifyCreateEvent(course=c, event=e)
return redirect(course_events, course_id)
else:
variables['form'] = form
variables.update(csrf(request))
return course(request, course_id, "Invalid event creation fields!!")
return redirect(index)
def create(request):
form = EventForm(request.POST or None)
if form.is_valid():
event = form.save(commit=False)
event.creator = request.user
guessed_date = None
for word in event.description.split():
try:
guessed_date = parse(word)
break
except ValueError:
continue
event.start_date = guessed_date
event.save()
request.user.message_set.create(message="Your event has posted.")
if "next" in request.POST:
next = request.POST["next"]
else:
next = reverse("ev_tonight")
return HttpResponseRedirect(next)
return render_to_response("events/create.html", {"form": form}, context_instance=RequestContext(request))
def change(request, id):
# visibility check
event = get_object_or_404(Event, pk=id)
parent = helpers.get_obj(ct=event.content_type, id=event.object_id)
if not helpers.is_visible(request.user, parent):
return render_to_response('denied.html', context_instance=RequestContext(request))
if request.method == 'POST':
#request.POST.update( { 'owner':request.user.id, 'object_id':id,
# 'content_type':ct.id, 'content_obj': obj, } )
form = EventForm(request.POST, instance=event)
if form.is_valid():
ev = form.save()
return HttpResponseRedirect(ev.get_absolute_url())
else:
form = EventForm(instance=event)
context = { 'form':form, 'object':parent, 'content_type':event.content_type }
context.update(locals())
return render_to_response('events/events_add.html', context,\
context_instance = RequestContext(request))
def post(self, request, event_id):
event = self.get_event(event_id)
base_ticket = self.get_base_ticket(event_id)
event_form = EventForm(request.POST, instance=event)
base_ticket_price_form = BaseTicketPriceForm(request.POST, instance=base_ticket)
upload_form = UploadBaseTicketEdit(request.POST, request.FILES)
if not(event_form.is_valid() and base_ticket_price_form.is_valid() and upload_form.is_valid()):
return render(request, self.template_name,
{'upload_form': upload_form, 'event_form': event_form,
'base_ticket_price_form': base_ticket_price_form, 'base_ticket': base_ticket,
'event_id': event.id, 'pdf_exists': self.pdf_exists(event_id)})
# if forms are valid:
pdf_file = self.get_pdf_file_or_None(request.FILES)
if pdf_file:
pdf_object = ProcessBaseTicket(pdf_file)
if not pdf_object.successful:
messages.add_message(request, messages.ERROR, pdf_object.message)
return render(request, self.template_name,
{'upload_form': upload_form, 'event_form': event_form,
'base_ticket_price_form': base_ticket_price_form, 'base_ticket': base_ticket,
'event_id': event.id, 'pdf_exists': self.pdf_exists(event_id)})
else:
base_ticket.link = SavePDF.save_base_ticket_return_filepath(pdf_object, event_id)
base_ticket.price = request.POST.get('price')
base_ticket.save()
event = event_form.save()
messages.add_message(request, messages.SUCCESS, message_text.event_update_successful)
return redirect('buy_ticket:available_tickets', event.id)
