def preferences(request):
context = RequestContext(request)
context_dict = get_context_dictionary(request)
sports = Sport.objects.all()
context_dict['sports'] = sports
# Make sure the user is valid. Return 401 Unauthorized if not.
if not request.user.is_authenticated() or not request.user.is_active:
return HttpResponseRedirect('/login/')
profile = UserProfile.objects.get(user=request.user)
context_dict['profile'] = profile
context_dict['cities'] = City.objects.all().order_by('city')
if request.method == "POST":
context_dict['updated'] = False
form = PreferencesForm(data = request.POST)
if form.is_valid():
user = request.user
user.last_name = request.POST['last_name']
user.first_name = request.POST['first_name']
user.email = request.POST['email']
if len(request.POST['password']) != 0:
user.set_password(request.POST['password'])
profile.about = request.POST['about']
cities = City.objects.filter(city=request.POST['city'])
if cities.exists():
profile.city = cities[0]
user.save()
profile.save()
context_dict['updated'] = True
return render_to_response('preferences.html', context_dict, context)
def preferences(request):
form = PreferencesForm(request.POST or None,
instance=request.user.userprofile)
if form.is_valid():
form.save()
return render(request, 'accounts/preferences.html', {'form': form})
def preferences(request):
user = request.user
profile = user.get_profile()
if request.method == "POST":
form = PreferencesForm(request.POST)
if form.is_valid():
return HttpResponseRedirect("/user/%d/" % user.id) # Redirect after POST
else:
form = PreferencesForm({"first_name": user.first_name, "last_name": user.last_name, "email": user.email})
return render_to_response("accounts/preferences.html", {"form": form}, context_instance=RequestContext(request))
def preferences(request, *args, **kws):
user = get_requestor(request)
try:
preferences = user.preference
except ObjectDoesNotExist:
preferences = Preference(user = user)
preferences.save()
form = PreferencesForm(initial = {'timeZone' : preferences.timeZone})
if request.method == "POST":
form = PreferencesForm(request.POST)
if form.is_valid():
preferences.timeZone = form.cleaned_data['timeZone']
preferences.save()
return HttpResponseRedirect("/profile/%s" % user.id)
return render_to_response('users/preferences.html'
, {'form' : form
, 'u' : user
})
def create_new(request, template_name):
""" Start process of creating new VPN certificate """
if request.method == "POST":
if not request.session.test_cookie_worked():
return render_to_response("please_enable_cookies.html", {},
context_instance=RequestContext(request))
request.session.delete_test_cookie()
form = PreferencesForm(request.POST)
if form.is_valid():
data = {'email': get_user(request.user.username)['mail'][0],
'computer_type': form.cleaned_data['computer_type'],
'computer_owner': form.cleaned_data['computer_owner'],
'employment': form.cleaned_data['employment']}
request.session['preferences'] = data
return HttpResponseRedirect(reverse('create_new_upload'))
else:
request.session.flush()
request.session['session_enabled'] = True
form = PreferencesForm()
request.session.set_test_cookie()
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def create_new(request, template_name):
""" Start process of creating new VPN certificate """
if request.method == "POST":
if not request.session.test_cookie_worked():
return render_to_response("please_enable_cookies.html", {},
context_instance=RequestContext(request))
request.session.delete_test_cookie()
form = PreferencesForm(request.POST)
if form.is_valid():
data = {
'email': get_user(request.user.username)['mail'][0],
'computer_type': form.cleaned_data['computer_type'],
'computer_owner': form.cleaned_data['computer_owner'],
'employment': form.cleaned_data['employment']
}
request.session['preferences'] = data
return HttpResponseRedirect(reverse('create_new_upload'))
else:
request.session.flush()
request.session['session_enabled'] = True
form = PreferencesForm()
request.session.set_test_cookie()
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def blackout_worker(request, kind, forObj, b_id, requestor, urlRedirect):
"Does most of the work for processing blackout forms"
try:
# use the requestor's time zone preference - not the users,
# since this could be for a project blackout.
tz = requestor.preference.timeZone
except ObjectDoesNotExist:
tz = "UTC"
tz_form = PreferencesForm(initial = {'timeZone' : tz})
if request.method == 'POST':
tz_form = PreferencesForm(request.POST)
if tz_form.is_valid():
tzp = tz_form.cleaned_data['timeZone']
else:
tz_form = PreferencesForm()
tzp = tz
f = BlackoutForm(request.POST)
f.format_dates(tzp, request.POST)
if f.is_valid():
if request.POST.get('_method', '') == 'PUT':
b = Blackout.objects.get(id = b_id)
else:
if kind == "project_blackout":
b = Blackout(project = forObj)
else:
b = Blackout(user = forObj)
b.initialize(tzp, f.cleaned_start, f.cleaned_end, f.cleaned_data['repeat'],
f.cleaned_until, f.cleaned_data['description'])
revision.comment = get_rev_comment(request, b, "blackout")
return HttpResponseRedirect(urlRedirect)
else:
b = Blackout.objects.get(id = b_id) if b_id is not None else None
if request.GET.get('_method', '') == "DELETE" and b is not None:
b.delete()
return HttpResponseRedirect(urlRedirect)
f = BlackoutForm.initialize(b, tz) if b is not None else BlackoutForm()
blackoutUrl = "%d/" % int(b_id) if b_id is not None else ""
# the forms we render have different actions according to whether
# these blackouts are for users or projects
if kind == "project_blackout":
for_name = forObj.pcode
form_action = "/project/%s/blackout/%s" % (forObj.pcode, blackoutUrl)
cancel_action = "/project/%s" % forObj.pcode
else:
for_name = forObj.display_name()
form_action = "/profile/%d/blackout/%s" % (forObj.id, blackoutUrl)
cancel_action = "/profile/%d" % forObj.id
return render_to_response("users/blackout_form.html"
, {'form' : f
, 'b_id' : b_id
, 'action' : form_action
, 'cancel' : cancel_action
, 'for_name' : for_name
, 'tz' : tz
, 'tz_form' : tz_form
})
