def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data = request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit = False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form=UserForm()
profile_form = UserProfileForm()
context_dict = {'user_form': user_form, 'profile_form':profile_form, 'registered':registered}
bar_list = Bar.objects.order_by('-numero_visitas')
context_dict['bares'] = bar_list
return render(request, 'rango/register.html', context_dict)
def register_profile(request):
registered = False
if request.method == 'POST':
form = UserProfileForm(data = request.POST)
if form.is_valid():
profile = form.save(commit=False)
User = UserModel() # imported above
current_user = User.objects.get(username = request.user.username)
profile.user = current_user # form.user link comes from request object
print profile.user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Now we save the UserProfile model instance to the DB
profile.save()
# Update our variable to tell the template registeration was succesful
registered = True
return index(request)
else:
print form.errors
else:
# If the request was not a POST, display the form to enter details
# (i.e. upon first load)
form = UserProfileForm()
# Bad form (or form details), no form supplied...
# Render the form with error messages (if any).
return render(request, 'registration/profile_registration.html', {'form': form})
def register(request):
if request.session.test_cookie_worked():
print ">>>>Test cookie worked !!!"
request.session.delete_test_cookie()
registered = False
if request.method == "POST":
user_form = UserForm(data = request.POST)
profile_form = UserProfileForm(data = request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
print "Part 1 done"
profile = profile_form.save(commit = False)
profile.user = user
print "Part 1.5 done"
if 'pic' in request.FILES:
profile.pic = request.FILES['pic']
profile.save()
print "Part 2 done"
registered = True
else:
print user_form.errors, profile_form.errors
else:
print "Part 3 executing"
user_form = UserForm()
profile_form = UserProfileForm()
print "registered = ",registered
return render(request,
'rango/register.html',
{'user_form': user_form, 'profile_form':profile_form, 'registered': registered })
def register(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render_to_response('rango/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered,}, context)
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password) # Hash the password
user.save() # Save the password
profile = profile_form.save(commit=False)
profile.user = user
# Check if user provides a profile picture
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
# If this is not a HTTP POST, then render the forms for input
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request, 'rango/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def register(request):
context = RequestContext(request)
registered = False
# Post request
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save() # does this really save form data to the database?
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
# not a HTTP POST
else:
user_form = UserForm()
profile_form = UserProfileForm()
# render template
return render_to_response('rango/register.html', {'user_form': user_form,
'profile_form': profile_form, 'registered': registered, 'cat_list': get_category_list()}, context)
def register(request):
context = RequestContext(request)
registered = False
if request.session.test_cookie_worked():
print ">>>>>TEST COOKIE WORKED"
request.session.delete_test_cookie()
if request.POST:
form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if form.is_valid() and profile_form.is_valid():
user = form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
form.errors, profile_form.errors
else:
form = UserForm()
profile_form = UserProfileForm()
return render_to_response('rango/register.html',{'form':form,'profile_form':profile_form,'registered':registered},context)
def register(request):
context=RequestContext(request)
registered = False
if(request.method=="POST"):
#process the form
user_form=UserForm(data=request.POST)
profile_form=UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user=user_form.save()
user.set_password(user.password)
user.save()#hashing the pwd
profile=profile_form.save(commit=False)
profile.user=user#This is where we populate the user attribute of the UserProfileForm form, which we hid from users
if 'picture' in request.FILES:
profile.picture=request.FILES['picture']
profile.save()
registered=True
else:
print user_form.errors, profile_form.errors
else:
user_form=UserForm()
profile_form=UserProfileForm()
return render_to_response(
'rango/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered},
context)
def register_profile(request):
if request.method=='POST':
user_id=request.POST['user_id']
old_profile_form=None
try:
old_profile_form=UserProfile.objects.get(user_id=user_id)
except:
pass
profile_form=UserProfileForm(data=request.POST)
user=None
try:
user=User.objects.get(pk=user_id)
except:
pass
if user and profile_form.is_valid():
if not old_profile_form:
profile=profile_form.save(commit=False)
profile.user=user
if 'picture' in request.FILES:
profile.picture=request.FILES['picture']
profile.save()
else:
old_profile_form.website=request.POST['website']
if 'picture' in request.FILES:
old_profile_form.picture=request.FILES['picture']
old_profile_form.save()
return redirect('/rango/')
else:
print profile_form.errors
return render(request,'rango/404.html',{})
else:
profile_form=UserProfileForm()
return render(request,'registration/profile_registration.html',{ 'profile_form':profile_form, })
def register(request):
context = RequestContext(request)
context_dict = {'cat_list': get_category_list()}
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picure = request.FILES['picture']
profile.save()
registered = True
else:
context_dict['errors'] = user_form.errors + profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict['user_form'] = user_form
context_dict['profile_form'] = profile_form
context_dict['registered'] = registered
return render_to_response('rango/register.html', context_dict, context)
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors(), profile_form.errors()
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request, 'rango/register.html', {'user_form': user_form,
'profile_form': profile_form, 'registered': registered})
def register(request):
if request.session.test_cookie_worked():
print ">>>Test cookie worked!"
request.session.delete_test_cookie()
context = RequestContext(request)
categories = get_category_list()
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render_to_response('rango/register.html',
dict(user_form=user_form, profile_form=profile_form, registered=registered,
categories=categories),
context)
def register(request):
#if request.session.test_cookie_worked():
# print ">>>> TEST COOKIE WORKED!"
# request.session.delete_test_cookie()
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user=user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
#user1 = authenticate(username = user.username,password=user.password)
#login(request,user1)
#return HttpResponseRedirect('/rango/')
else :
print user_form.errors, profile_form.errors
else :
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,'rango/register.html',
{'user_form':user_form,'profile_form':profile_form,'registered':registered})
def register(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
calc_form = CalcForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid() and calc_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
calc = calc_form.save(commit=False)
calc.user = user
calc.gender = profile.gender
calc.height_for_calc = profile.height
calc.weight_for_calc = profile.weight
calc.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
calc_form = CalcForm()
return render_to_response('rango/register.html',{'user_form': user_form, 'profile_form': profile_form, 'calc_form': calc_form, 'registered' : registered}, context)
def register(request):
# boolean for telling the template whether registration is successful
if request.session.test_cookie_worked():
print ">>>> TEST COOKIE WORKED!"
request.session.delete_test_cookie()
register = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
register = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request, 'rango/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'register': register})
def register(request):
registered = False
## Testing cookies
if request.session.test_cookie_worked():
print ">>>>> Test cookie worked!"
# request.session.delete_test_cookie()
## Testing cookies
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit = False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request, 'rango/register.html', {'user_form':user_form, 'profile_form':profile_form, 'registered': registered, 'cat_list':cat_list, })
def register(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors , profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
def register(request):
registered = False
print 'reg', request.method
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES('picture')
profile.save()
registered = True
else:
print 'user profile form errors', user_form.errors, profile_form.errors
else:
user_form=UserForm()
profile_form = UserProfileForm()
context = {'user_form': user_form, 'profile_form': profile_form,'registered': registered}
print 'context', context
return render(request, 'rango/register.html', context)
def register(request):
if request.session.test_cookie_worked():
print 'Test cookie worked'
request.session.delete_test_cookie()
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict = {'user_form' : user_form, 'profile_form': profile_form, 'registered':registered}
return render_to_response('rango/register.html', context_dict, context)
def register(request):
registered = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if "picture" in request.FILES:
profile.picture = request.FILES["picture"]
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, "rango/register.html", {"user_form": user_form, "profile_form": profile_form, "registered": registered}
)
def add_profile(request):
# A HTTP POST?
if request.method == 'POST':
form = UserProfileForm(request.POST)
# Have we been provided with a valid form?
if form.is_valid():
userProfile = form.save(commit=False)
userProfile.user_id = request.user.id
if 'picture' in request.FILES:
userProfile.picture = request.FILES['picture']
# Save the new category to the database.
form.save(commit=True)
# Now call the index() viewed.
# The user will be shown the homepage
return index(request)
else:
# If the request was not a POST, display the form to enter details.
form = UserProfileForm()
# Bad form (or form details), no form supplied...
# Render the form with error messages (if any).
return render(request, 'rango/profile_registration.html',{'form':form})
def register(request):
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request, 'rango/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def edit_profile(request):
url = '/rango/'
try:
profile = request.user.userprofile
except UserProfile.DoesNotExist:
profile = UserProfile(user=request.user)
if request.method == 'POST':
profile_form = UserProfileForm(data=request.POST, instance=profile)
if profile_form.is_valid():
profile_form.save(commit=False)
if 'picture' in request.FILES:
print "picture"
profile.picture = request.FILES['picture']
profile.save()
return redirect(url)
else:
print profile_form.errors
else:
profile_form = UserProfileForm(instance=profile)
return render(request,
'rango/edit_profile.html',
{'profile_form': profile_form} )
def registration_register(request):
# if request.session.test_cookie_worked():
# print ">>>>> TEST COOKIE WORKED!"
# request.session.delete_test_cookie()
registered = False
if request.method=="POST":
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'rango/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def register(request):
registed = False
if request.method == "POST":
user_form = UserForm(request.POST)
user_profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and user_profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
user_profile = user_profile_form.save(commit = False)
user_profile.user = user
if 'picture' in request.FILES:
print "co picture"
user_profile.picture = request.FILES['picture']
user_profile.save()
registed = True
else:
user_form = UserForm()
user_profile_form = UserProfileForm()
return render(request,'rango/register.html',{
'user_form' : user_form,
'user_profile_form' : user_profile_form,
'registed' : registed,
})
def register(request):
if request.session.test_cookie_worked():
print ">>>> TEST COOKIE WORKED!"
request.session.delete_test_cookie()
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == "POST":
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
# If so, we need to get it from the input form and put it in the UserProfile model.
if "picture" in request.FILES:
profile.picture = request.FILES["picture"]
# Now we save the UserProfile model instance.
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render(
request, "rango/register.html", {"user_form": user_form, "profile_form": profile_form, "registered": registered}
)
def register(request):
# A boolean value for telling the template
# whether the registration was successful
# Set to False initially. Code changes value to
# True when registration succeeds
registered = False
# If it's a HTTP POST, we're interested in processing form data
if request.method == 'POST':
# Attempt to grab information from the faw form information
# Note that we make use of both UserForm and UserProfileForm
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid..
if user_form.is_valid() and profile_form.is_valid():
#Save the user's form data to the database
user = user_form.save()
# Now we hash the password with the set_password method
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance
# Since we need to set the user attribute ourselves,
# we set commit=False. This delays saving the model
# Until we're ready to avoid integrity problems
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
# if so we need to get it from the input form and
# put it in the UserProfile model.
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Now we save the UserProfile model instane
profile.save()
# Update our variable to indicate that the template
# registartion was successful
registered = True
else:
# Invalid form or forms - mistakes or something else
# Print problems to the terminal.
print(user_form.errors, profile_form.errors)
else:
# Not a HTTP POST, so we render our form using two ModelForm instances
# These forms will be blank, ready for user input
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context
return render(request,'rango/register.html',
{'user_form': user_form,
'profile_form': profile_form,
'registered': registered})
def register(request):
#Like before, get the request's context
context = RequestContext(request)
cat_list = get_category_list()
# A boolean value for telling the template whether the registration was successful
# Set to False initiall. Code changes value to True when registration succeeds
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information
# Note that we make use of both UserForm and UserProfileForm
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance
# Since we need to set the user attribute ourselves, we set commit=False
# This delays saving the model until we're ready to avoid integrity problems
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
# If so, we need to get it from the input form and put it in the UserProfile model
if 'picture' in request.FILES:
profile.picture - request.FILES['picture']
# Now we save the UserProfile model instance
profile.save()
# Update our variable to tell the template registration was successful
registered = True
# Invalid form or forms - mistakes or somethign else?
# Print problems to the terminal
# They'll also be shown to the user
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using to ModelForm instances
# These forms will be blank, ready for user input
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict = {'user_form': user_form, 'profile_form': profile_form,
'registered': registered, 'cat_list': cat_list}
# Render the template depending on the context
return render_to_response('rango/register.html', context_dict, context)
def register_profile(request):
if request.user.is_authenticated():
user = request.user
registered = False
if request.method == 'POST':
profile_form = UserProfileForm(request.POST)
if profile_form.is_valid():
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print profile_form.errors
else:
profile_form = UserProfileForm()
return render(request,
'registration/profile_registration.html',
{'profile_form': profile_form, 'registered': registered})
def add_profile(request):
username = ''
#if method is post, we'll want to process this data
if request.method == 'POST':
profile_form = UserProfileForm(data=request.POST)
if profile_form.is_valid():
profile = profile_form.save(commit=False)
profile.user = request.user
if request.user.is_authenticated():
username = request.user.get_username()
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
#add a redirect to the view_profile page when you make one
else:
print profile_form.errors
else:
profile_form = UserProfileForm()
return render(request,'registration/profile_registration.html', {'profile_form': profile_form,
'username': username})
def register_profile(request):
form = UserProfileForm()
if request.method == 'POST':
form = UserProfileForm(request.POST, request.FILES)
if form.is_valid():
user_profile = form.save(commit=False)
user_profile.user = request.user
user_profile.save()
return redirect('index')
else:
print(form.errors)
context_dict = {'form':form}
return render(request, 'rango/profile_registration.html', context_dict)
def register(request):
if request.session.test_cookie_worked():
print ">>>> Test cookie worked!"
request.session.delete_test_cookie()
context = RequestContext(request)
#boolean to indicate whether registration successful
registered = False
#post request => process data
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
#forms valid
if user_form.is_valid() and profile_form.is_valid():
#save user's form to database
user = user_form.save()
#hash pw with set_pw, updatae user object
user.set_password(user.password)
user.save()
#sort out userprofile insstance
profile = profile_form.save(commit=False)
profile.user = user
#picture?
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
#save userprof model instance
profile.save()
registered = True
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render_to_response(
'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
}, context)
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
# If so, we need to get it from the input form and
# put it in the UserProfile model.
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
# Update our registration variable to indicate that the template
# registration was successful.
registered = True
else:
# Invalid form or forms - print problems to the terminal
print(user_form.errors, profile_form.errors)
else:
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render(
request, 'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register(request):
registered = False
# if it's a HTTP POST, we're interested in processing a form
if request.method == 'POST':
#Grab info from the raw form
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
#save the user's form data to the database
user = user_form.save()
#Now let's hash the password
user.set_password(user.password)
user.save()
#since we set the user attributes ourselves, commit=False
profile = profile_form.save(commit=False)
profile.user = user
#did the user provide a profile image
# if so, we need to get it from the input form and put it in the UserProfile model
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
#save the userprofile model instance
profile.save()
registered = True
#invalid form
else:
print user_form.errors, profile_form.errors
#not an HTTP POST, so we render our form using 2 ModelForm instances
#these forms will be blank, ready for user input
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register(request):
# cookie testing
if request.session.test_cookie_worked():
print ">>> TEST COOKIE WORKED!"
request.session.delete_test_cookie()
context = RequestContext(request)
registered = False
# boolean variable to tell template about registration outcome.
# initially false
if request.method =='POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
# save the user's form data to db
user = user_form.save()
# hash the password with set_password
user.set_password(user.password)
user.save()
# we save profile form, don't commit to db immediately, just get var name
profile = profile_form.save(commit = False)
# set profile's user association ourselves
profile.user = user
"""
# need to install pillow module first
if 'picture ' in request.FILES:
profile.picture = request.FILES['picture']
"""
# now save UserProfile's model instance
profile.save()
#registration succesfull
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form=UserForm()
profile_form =UserProfileForm()
return render_to_response('rango/register.html',{'user_form':user_form, 'profile_form': profile_form, 'registered': registered},context)
def register(request):
#Code changes value to
# True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
# Update our variable. registration was successful.
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render(
request, 'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register(request):
# Boolean value to store if the registration was successful.
registered = False
# If the form has been submitted(POST)
if (request.method == 'POST'):
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# Check if both forms are filled out correctly:
if user_form.is_valid() and profile_form.is_valid():
# save the users registration data
user = user_form.save()
# now we hash the password and add it to the database
user.set_password(user.password)
user.save()
# We can now deal with the user profile side of things
profile = profile_form.save(commit=False)
profile.user = user
# Now to add the profile picture if provided!
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Save the new user and set flag to show it worked.
profile.save()
registered = True
else:
# Invalid form(s)
print(user_form.errors, profile_form.errors)
else:
# have to display the forms for the user to fill in
user_form = UserForm()
profile_form = UserProfileForm()
# render a display either a new registration form, errors in a submitted form
# or a success message if succesfully registed user
return render(
request, 'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered,
})
def register(request):
registered = False
# If it's a http POST, process form data
if request.method == 'POST':
# Retrieve data from the forms
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
# Save the form data to the database
user = user_form.save()
# set_password hashes the password, then we save the user
user.set_password(user.password)
user.save()
# commit=False delays saving the model to avoid integrity issues
# Create the one-to-one relationship between the profile and user
profile = profile_form.save(commit=False)
profile.user = user
# If user uploaded a picture, add it, then save profile to db
if 'picture' in request.FILES:
profile_picture = request.FILES['picture']
profile.save()
# At this point, user is registered
registered = True
else:
# Display errors
print(user_form.errors, profile_form.errors)
else:
# Render using Blank forms ready for user input
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'rango/register.html',
context={
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register_profile(request):
if request.method == 'POST':
profile_form = UserProfileForm(request.POST)
if profile_form.is_valid():
if request.user.is_authenticated():
profile = profile_form.save(commit=False)
user = User.objects.get(id=request.user.id)
profile.user = user
try:
profile.picture = request.FILES['picture']
except:
pass
profile.save()
return index(request)
else:
form = UserProfileForm(request.GET)
return render(request, 'rango/profile_registration.html',
{'profile_form': form})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# if the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
# hash the password with the set_password method
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
def profile(request, username):
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return redirect('index')
userprofile = UserProfile.objects.get_or_create(user=user)[0]
form = UserProfileForm({'website': userprofile.website, 'picture': userprofile.picture})
if request.method == 'POST':
form = UserProfileForm(request.POST, request.FILES, instance=userprofile)
if form.is_valid():
form.save(commit=True)
return redirect('profile', user.username)
else:
print(form.errors)
return render(request, 'rango/profile.html', {'userprofile': userprofile, 'selecteduser': user, 'form': form})
def register_profile(request):
if request.method == 'POST':
form = UserProfileForm(request.POST)
if form.is_valid():
profile = form.save(commit=False)
profile.user = request.user
profile.save()
return index(request)
else:
print form.errors
else:
form = UserProfileForm()
return render(request, 'registration/profile_registration.html',
{'form': form})
def register(request):
# Sets register to False initially
registered = False
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Hash pssword
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
# Update registration variable
registered = True
else:
# Invalid form or forms
# Print problems to the terminal.
print(user_form.errors, profile_form.errors)
else:
# Not a HTTP POST, so we render our form using two ModelForms
# These forms will be blank, ready for user input.
user_form = UserForm
profile_form = UserProfileForm()
return render(
request, 'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register(request):
# Boolean for when registration was successful, false initially,
# then set to true if successful
registered = False
# If it's a HTTP POST, we're interested in processing form data
if request.method == 'POST':
# Attempt to get information from the form
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database
user = user_form.save()
# Hash the password then update the user object
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
# Check if there's a profile picture
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Sve the UserProfile model instance
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errrors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'rango/register.html',
{'user_form': user_form,
'profile_form':profile_form,
'registered': registered})
def register(request):
# tell template if registration was successful
registered = False
# if POST, process form data
if request.method == "POST":
# try to grab information from raw form
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# if both forms valid
if user_form.is_valid() and profile_form.is_valid():
# save to database
user = user_form.save()
# hash PW, update
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
# if picture provided
if "picture" in request.FILES:
profile.picture = request.FILES["picture"]
profile.save()
registered = True
else:
print(user_form.errors, profile.form_errors)
# if not POST, render blank form
else:
user_form = UserForm()
profile_form = UserProfileForm()
# render template depending on context
return render(request,
"rango/register.html",
{"user_form":user_form,
"profile_form":profile_form,
"registered":registered})
def register(request):
#if request.session.test_cookie_worked():
#print '>>>> TEST COOKIE WORKED!'
#request.session.delete_test_cookie()
#just a test^
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
#user = user_form
user.set_password(user.password)
user.save()
profile = profile_form.save(
commit=False
) #This is unnecessary as well since pic/url is not required
profile.user = user #Do we need this??
#I guess yes, because this 'user' is new one, and needs to referenced to newly created profile...
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict = {'user_form': user_form}
context_dict['profile_form'] = profile_form
context_dict['registered'] = registered
cat_list = get_cat_list()
context_dict['cat_list'] = cat_list
return render(request, 'rango/register.html', context_dict)
def post(self, request, username):
try:
(user, user_profile, form) = self.get_user_details(username)
except TypeError:
return redirect(reverse('rango:index'))
form = UserProfileForm(request.POST, request.FILES, instance=user_profile)
if form.is_valid():
form.save(commit=True)
return redirect('rango:profile', user.username)
else:
print(form.errors)
context_dict = {'user_profile': user_profile,
'selected_user': user,
'form': form}
return render(request, 'rango/profile.html', context_dict)
def register(request):
# A boolean value for telling the template
# whether the registration was successful.
# Set to False initially. Code changes value to
# True when registration succeeds.
registered = False
#HTTP post
if request.method == 'POST':
#Attempt to take infor
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'rango/register.html',
{'user_form': user_form,
'profile_form': profile_form,
'registered': registered})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'rango/register.html',
{'user_form': user_form,
'profile_form': profile_form,
'registered': registered})
def post(self, request):
profile_form = UserProfileForm(request.POST, request.FILES)
# if the form is valid
if profile_form.is_valid():
# now sort out the UserProfile instance
# needed the User attribute first so commit = False for now
profile = profile_form.save(commit=False)
profile.user = request.user
# did the user provide a picture
# if 'picture' in request.FILES:
# profile.picture = request.FILES['picture']
profile.save()
return redirect(reverse('rango:index'))
else:
print(profile_form.errors)
context_dict = {'form': profile_form}
return render(request, 'rango/profile_registration.html', context_dict)
def register_profile(request):
form = UserProfileForm()
if request.method == 'POST':
profile_form = UserProfileForm(request.POST, request.FILES)
if profile_form.is_valid():
profile = profile_form.save(commit=False)
profile.user = request.user
profile.save()
return HttpResponseRedirect(reverse('index'))
else:
print(form.errors)
context_dict = {'form': form}
return render(request, 'registration/profile_registration_form.html',
context_dict)
def register(request):
context = RequestContext(request)
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render_to_response(
'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
}, context)
def register(request):
# boolean value to check if the registration was successful
registered = False
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
# save the user_form data
user = user_form.save()
# hash the password
user.set_password(user.password)
user.save()
# deal with the UserProfile, we don't save the model because
# we have some attributes to set
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# save the UserProfile instance
profile.save()
# the registration was successful
registered = True
else:
# invalid form or forms
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict = {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
}
return render(request, 'rango/register.html', context=context_dict)
def register(request):
# boolean for telling the template if registration was sucessful
# starts off as false and then set to true when successful
registered = False
if request.method == "POST":
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
# hash password
user.set_password(user.password)
user.save()
# commit=False to avoid integrity problems from manually setting attributes
profile = profile_form.save(commit=False)
profile.user = user
if "picture" in request.FILES:
profile.picture = request.FILES["picture"]
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
# Not a POST Method then render blank forms
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request,
"rango/register.html",
context={
"user_form": user_form,
"profile_form": profile_form,
"registered": registered,
},
)
def register(request):
#Was registration successful?
registered = False
#We process form data only if the request is POST
if request.method == 'POST':
#Get information from the raw form
#Use both UserForm and UserProfileForm
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
#Save the data
user = user_form.save()
#Now we hash the password with set_password() and save the user object
user.set_password(user.password)
user.save()
#UserProfile instance
#Set attribute ourselvs so commit=False (delays save)
profile = profile_form.save(commit=False)
profile.user = user
#Picture
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True #Successful registration
else:
#Invalid form
print(user_form.errors, profile_form.errors)
else:
#Not a POST - create new blank forms for input
user_form = UserForm()
profile_form = UserProfileForm()
return render(request, 'rango/register.html',
context= {'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def register(request):
registered = False
# If POST, process data
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
# Now sort out user profile
profile = profile_form.save(commit=False)
profile.user = user
# Profile picture provided?
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Save UserProfile
profile.save()
# Update success variable
registered = True
else:
#Invalid form etc
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register_profile(request):
if not request.user.is_authenticated:# 限制未登录用户访问
return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
# print("#"*100)
else:
# A HTTP POST?
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# Have we been provided with a valid form?
if profile_form.is_valid() and user_form.is_valid():
user = user_form
# Save the new category to the database.
profile = profile_form.save(commit=False)
profile.user=user
# Did the user provide a profile picture?
# If so, we need to get it from the input form and put it in the UserProfile model.
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# Now we save the UserProfile model instance.
profile.save()
# Now call the index() view.
# The user will be shown the homepage.
return index(request)
else:
# The supplied form contained errors - just print them to the terminal.
print (profile_form.errors)
else:
# If the request was not a POST, display the form to enter details.
user_form = UserForm()
profile_form = UserProfileForm()
# Bad form (or form details), no form supplied...
# Render the form with error messages (if any).
print("#"*100)
return render(request, 'rango/profile_registration.html', {'profile_form': profile_form,'user_form':user_form})
def register(request):
"""View that handles registering a new user"""
registered = False # A boolean value for telling the template whether the registration was successful
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
#Check if the two forms are valid
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
#Did the user provide a profile picture?
#If so, we need to save it in the UserProfile model
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
#Now we save the UserProfile model instance
profile.save()
#Update our boolean variable to tell the template registration is successful!
registered = True
#what do we do if form is not valid?
#Print the problems. Event log
#show them to the user
else:
print user_form.errors, profile_form.errors
#Not an HTTP POST? Sweet! let's render the form using ModelForm instances.
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict = {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
}
return render(request, 'rango/register.html', context_dict)
def register(request):
# Set False initially, changes to True when registration succeeds.
registered = False
if request.method == 'POST':
# Attempt to grap the raw form information, both UserForm and UserProfileForm.
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
# Hash the password, and update the user object
user.set_password(user.password)
user.save()
# The commit = False delays saving the model until we avoid the integrity problems
profile = profile_form.save(commit=False)
profile.user = user
# if user provide a picture, we get it from input form, put it in UserProfile model
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
# Update the status of registered variable
registered = True
else:
# Invalid form or forms - mistakes or something? print it in the terminal.
print(user_form.errors, profile_form.errors)
else:
# Not a HTTP POST, so render the forms, these forms will be blank for user input.
user_form = UserForm()
profile_form = UserProfileForm()
# Render depending on the status or forms
return render(request,
'rango/register.html',
context={
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register(request):
#prset reg = false, if user has reg, will --> true
registered = False
if request.method == 'POST':
#get info from raw from, uses *BOTH* forms
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
#hash the pw
user.set_password(user.password)
user.save()
#set commit to false to avoid integrity problems?
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
# if problems, send errors to terminal
else:
print(user_form.errors, profile_form.errors)
#if not a post request, render blank forms
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'rango/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
