def user_login(request):
# 从 get 或者 post 请求中获取 next 参数值
# get 请求中，next 通过 url 传递，即 /?next=value
# post 请求中，next 通过表单传递，即 <input type="hidden" name="next" value="{{ next }}"/>
redirect_to = request.POST.get('next', request.GET.get('next', ''))
print(redirect_to)
if request.method == 'POST':
user_login_form = UserProfileForm(request.POST)
if user_login_form.is_valid():
# cleaned_data 清洗出合法数据
# 检验账号、密码是否正确匹配数据库中的某个用户
# 如果均匹配则返回这个 user 对象
user = authenticate(
username=user_login_form.cleaned_data['username'],
password=user_login_form.cleaned_data['password'])
if user:
# 将用户数据保存在 session 中，即实现了登录动作
login(request, user)
# 登录成功之后，跳转到登录前的页面
return redirect(request.GET.get('next', '/'))
else:
return HttpResponse('账号或密码输入有误，请重新输入！！')
else:
return HttpResponse('账号或密码输入不合法！')
elif request.method == 'GET':
user_login_form = UserProfileForm()
return render(request, 'userprofile/login.html', locals())
else:
return HttpResponse('请使用GET或POST请求数据！！')
def user_profile(request):
if request.method == "POST":
form = UserProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
return redirect("userprofile.views.loggedin")
else:
iterator = itertools.count()
user = request.user
profile = user.profile
form = UserProfileForm(instance=profile)
foods = Food.objects.filter(user=user)
foodMaps = FoodMap.objects.filter(user=user)
companies = Company.objects.filter(user=user)
companyPhotos = CompanyPhoto.objects.filter(user=user)
foodPhotos = FoodPhoto.objects.filter(user=user)
args = {}
args.update(csrf(request))
args["form"] = form
args["user"] = user
args["foods"] = foods
args["foodMaps"] = foodMaps
args["companies"] = companies
args["companyPhotos"] = companyPhotos
args["foodPhotos"] = foodPhotos
args["iterator"] = iterator
return render(request, "userprofile/profile.html", args)
def test_form_doesnt_write_over_votes_or_date(self):
form = UserProfileForm(instance=self.u.profile, data={
'open_profile': True,
'user': self.u.pk
})
form.save()
profile = UserProfile.objects.get(user=self.u)
self.assertEqual(profile.last_voted_on, None)
def test_form_validation(self):
form = UserProfileForm(instance=self.u.profile, data={
'open_profile': True,
'user': self.u.pk
})
form.save()
count = UserProfile.objects.all().count()
self.assertEqual(count, 1)
def edit_profile(request):
if request.POST:
form = UserProfileForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/profile/')
else:
form = UserProfileForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['sidebar'] = Sidebar.objects.filter(pub_date__lte=timezone.now()).order_by('-pub_date')
return render(request, 'userprofile/edit_profile.html', args)
def post(self, request, *arg, **kwargs):
pk = self.kwargs.get('pk')
agrodealer = self.kwargs.get('agrodealer')
instance = None
errors = dict()
if pk:
instance = User.objects.filter(pk=pk)
if instance.exists():
instance = instance[0]
profile = instance.profile
if hasattr(instance, 'cooperative_admin'):
coop_admin = instance.cooperative_admin
user_form = UserForm(request.POST, instance=instance)
profile_form = UserProfileForm(request.POST, instance=instance)
if user_form.is_valid() and profile_form.is_valid():
try:
with transaction.atomic():
if not errors:
user = user_form.save(commit=False)
if not instance:
user.set_password(user.password)
user.save()
profile_form = UserProfileForm(request.POST,
instance=user.profile)
profile_form.save(commit=False)
profile_form.access_level = get_object_or_404(
AccessLevel, name='AGRODEALER')
profile_form.save()
inst_s = AgroDealer.objects.get(pk=agrodealer)
AgroDealerUser.objects.create(
agrodealer=inst_s,
user=user,
)
return redirect('agrodealer:agrodealer_user',
agrodealer=agrodealer)
except Exception as e:
log_error()
errors['errors'] = "Error %s" % e
data = {
'user_form': user_form,
'profile_form': profile_form,
'active': ['_agrodealer']
}
data.update(errors)
return render(request, self.template_name, data)
def create_profile(request):
if request.POST:
userprofile_form = UserProfileForm(request.POST, request.FILES, prefix='userprofile_form')
user_form = UserForm(request.POST, request.FILES, prefix='user_form')
if all([userprofile_form.is_valid(), user_form.is_valid()]):
user = user_form.save()
profile = userprofile_form.save(commit=False)
profile.user = user
profile.save()
else:
userprofile_form = UserProfileForm(prefix='userprofile_form')
user_form = UserForm(prefix='user_form')
return render(request, "user_profile.html", {
'userprofile_form': userprofile_form,
'user_form': user_form
})
def user_profile(request):
if request.method == "POST":
form = UserProfileForm(request.POST, instance = request.user.profile)
if form.is_valid():
form.save()
return HttpResponseRedirect('/profile')
else:
user=request.user
profile=user.profile
form=UserProfileForm(instance=profile)
user_profile = request.user.get_profile()
savedState = user_profile.savedState
args={}
args.update(csrf(request))
args['form']=form
return render_to_response('profile.html', args)
def post(self, request, *arg, **kwargs):
pk = self.kwargs.get('pk')
instance = None
profile = None
coop_admin = None
errors = dict()
if pk:
instance = User.objects.filter(pk=pk)
if instance.exists():
instance = instance[0]
profile = instance.profile
if hasattr(instance, 'cooperative_admin'):
coop_admin = instance.cooperative_admin
user_form = UserForm(request.POST, instance=instance)
profile_form = UserProfileForm(request.POST, instance=profile)
if user_form.is_valid() and profile_form.is_valid():
try:
with transaction.atomic():
if not errors:
user = user_form.save(commit=False);
if not instance:
user.set_password(user.password)
user.save()
profile_form = UserProfileForm(request.POST, instance=user.profile)
profile_form.save()
return redirect('profile:user_list')
except Exception as e:
log_error()
errors['errors'] = "Error %s" % e
data = {'user_form': user_form, 'profile_form': profile_form, 'coop_form': coop_form}
data.update(errors)
return render(request, self.template_name, data)
def signup(request):
if request.POST:
userprofile_form = UserProfileForm(request.POST, request.FILES, prefix='userprofile_form')
user_form = UserForm(request.POST, request.FILES, prefix='user_form')
if all([userprofile_form.is_valid(), user_form.is_valid()]):
user = user_form.save()
profile = userprofile_form.save(commit=False)
profile.user = user
profile.save()
user_login(request, user)
return HttpResponseRedirect(reverse("userprofile:login"))
else:
userprofile_form = UserProfileForm(prefix='userprofile_form')
user_form = UserForm(prefix='user_form')
return render(request, "signup.html", {
'userprofile_form': userprofile_form,
'user_form': user_form
})
def save_profile(request, form2, img):
dajax = Dajax()
try:
user2 = UserProfile.objects.get(user=request.user)
except:
user2 = UserProfile()
res = UserProfileForm(deserialize_form(form2), instance=user2)
if not res.is_valid() or res is None:
cd2 = {"form": res, "user": request.user}
html1 = render_to_string("user/get_form.html", cd2, RequestContext(request))
dajax.assign("#UpdateDiv", "innerHTML", html1)
return dajax.json()
res.save()
u = request.user
u.first_name = res.cleaned_data["first_name"]
u.last_name = res.cleaned_data["last_name"]
u.save()
return get_profile(request)
def edit_profile(request):
if request.method == 'POST':
form = UserProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/loggedin')
else:
user = request.user
profile = user.profile
form = UserProfileForm(instance=profile)
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('accounts/edit_profile.html', args, context_instance=RequestContext(request))
def checkout_completed(request, order_number):
"""
Handle successful checkouts
"""
save_info = request.session.get('save_info')
order = get_object_or_404(Order, order_number=order_number)
if request.user.is_authenticated:
userprofile = UserProfile.objects.get(user=request.user)
# Attach the user's profile to the order
order.user_profile = userprofile
order.save()
# Save the user's info
if save_info:
userprofile_data = {
'default_phone_number': order.phone_number,
'default_country': order.country,
'default_postcode': order.postcode,
'default_town_or_city': order.town_or_city,
'default_street_address1': order.street_address1,
'default_street_address2': order.street_address2,
'default_county': order.county,
}
user_profile_form = UserProfileForm(userprofile_data,
instance=userprofile)
if user_profile_form.is_valid():
user_profile_form.save()
messages.success(
request, f'Order successfully processed! \
Your order number is {order_number}. A confirmation \
email will be sent to {order.email}.')
if 'shoppingbag' in request.session:
del request.session['shoppingbag']
template = 'checkoutitems/checkout_completed.html'
context = {
'order': order,
}
return render(request, template, context)
def edit_profile(request, template="userprofile/edit_profile.html"):
"""
This view shows the profile form so that a user can edit it.
"""
profile_instance = get_object_or_404(UserProfile, user=request.user)
pic_instance = get_object_or_404(ProfilePic, user=request.user)
if request.method == 'POST':
profile_form = UserProfileForm(request.POST or None, instance=profile_instance)
pic_form = ProfilePicForm(request.POST or None, request.FILES or None, instance=pic_instance)
if profile_form.is_valid() & pic_form.is_valid():
profile_form.save()
pic_form.save()
return HttpResponseRedirect(reverse('userprofile_user_profile', kwargs = {'username': request.user.username}))
else:
return render(request, template, {'profile_form': profile_form, 'pic_form': pic_form}, context_instance=RequestContext(request))
else:
profile_form = UserProfileForm(instance=profile_instance)
pic_form = ProfilePicForm(instance=pic_instance)
return render(request, template, {'profile_form': profile_form, 'pic_form':pic_form}, context_instance=RequestContext(request))
def edit(request):
if request.method == 'POST': # If the form has been submitted...
form = UserProfileForm(request.POST) # A form bound to the POST data
if form.is_valid():
userprofile = UserProfile()
userprofile.user = request.user
userprofile.firstname = form.cleaned_data['firstname']
userprofile.lastname = form.cleaned_data['lastname']
userprofile.number = form.cleaned_data['number']
userprofile.serie = form.cleaned_data['serie']
userprofile.sexe = form.cleaned_data['sexe']
userprofile.phoneNumber = form.cleaned_data['phoneNumber']
userprofile.save()
return redirect('userprofile.views.display') # Redirect after POST
else:
return render(request,
'userprofile/userprofile_edit.html', {
'form': form,
}
)
else:
try:
userprofile = UserProfile.objects.get(pk=request.user)
form = UserProfileForm({
'firstname': userprofile.firstname,
'lastname': userprofile.lastname,
'number': userprofile.number,
'serie': userprofile.serie,
'sexe': userprofile.sexe,
'phoneNumber': userprofile.phoneNumber,
})
except Exception as ex:
print ex
form = UserProfileForm()
return render(request,
'userprofile/userprofile_edit.html', {
'form': form,
}
)
def user_profile(request):
if request.method == 'POST':
form = UserProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
# TODO: use url name here!
return HttpResponseRedirect('/accounts/profile/')
else:
user = request.user
profile = user.profile
form = UserProfileForm(instance=profile)
args = {}
args.update(csrf(request))
args['form'] = form
args['user_p'] = request.user
full_name = '%s %s' % (request.user.first_name, request.user.last_name, )
args['full_name'] = full_name
return render_to_response('profile.html', args)
def edit_profile(request):
if request.POST:
form = UserProfileForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/profile/')
else:
form = UserProfileForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['sidebar'] = Sidebar.objects.filter(pub_date__lte=timezone.now()).order_by('-pub_date')
if request.user.is_authenticated():
args['username'] = request.user.username
args['full_name'] = request.user.first_name + ' ' + request.user.last_name
args['form'] = args['form']
return render(request, 'account/edit_profile.html', args)
else:
return render(request, 'account/edit_profile.html', args)
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
profile.save()
registered = True
else:
print (user_form.errors,profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,'snatch/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
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'snatch/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def user_personal_info(request, valid_template_name, not_valid_template_name):
"""
Add personal info
"""
if request.method == 'POST':
try:
user = User.objects.get(username = request.user.username)
except User.DoesNotExist:
messages.error(request, "You are not a logged in user.")
return HttpResponseRedirect( reverse('auth_logout') )
try:
user_profile = UserProfile.objects.get(user__username = request.user.username)
except UserProfile.DoesNotExist:
messages.error(request, "User Profile is not created yet.")
return HttpResponseRedirect( reverse('auth_logout') )
form = UserProfileForm(request.POST)
if form.is_valid():
user_profile.country = request.POST.get('country', '')
user_profile.city = request.POST.get('city', '')
user_profile.website = request.POST.get('website', '')
user_profile.save()
userprofileform = UserProfileForm()
template_name = valid_template_name
context = {
'profile' : user_profile,
'userprofileform' : UserProfileForm(),
}
return render_to_response(template_name, context, context_instance=RequestContext(request))
template_name = not_valid_template_name
context = {
'profile': user_profile,
'userprofileform': form,
}
return render_to_response(template_name, context, context_instance=RequestContext(request))
def update_user_profile(request, user_id):
user = get_object_or_404(User, pk=user_id)
if request.user == user or request.user.is_superuser:
up = UserProfile.objects.get_or_create(user=user, defaults={ 'user' : user })
userprofile = up[0]
if request.method == 'POST':
f = UserProfileForm(request.POST, instance=userprofile)
if f.is_valid():
try:
f.save()
except:
messages.error(request,'There was a problem updating the user profile.')
else:
messages.success(request,'User profile updated successfully!.')
f = UserProfileForm(instance=userprofile)
return render_to_response('userprofile/update_user_profile.html', {
'form': f,
}, context_instance = RequestContext(request))
else:
return HttpResponseForbidden('You do not have access to this page.')
def user_profile(request):
args = {}
if request.method == 'POST':
form = UserProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/loggedin')
else:
user = request.user
profile = user.profile
form = UserProfileForm(instance=profile)
args.update(csrf(request))
args['form'] = form
return render_to_response('body/profile.html', args)
def get(self, request, *arg, **kwarg):
pk = self.kwargs.get('pk')
instance = None
profile = None
coop_admin = None
if pk:
user = User.objects.get(pk=pk)
if user:
instance = user
profile = instance.profile
if hasattr(instance, 'cooperative_admin'):
coop_admin = instance.cooperative_admin
user_form = UserForm(instance=instance)
profile_form = UserProfileForm(instance=profile)
data = {'user_form': user_form, 'profile_form': profile_form}
return render(request, self.template_name, data)
def user_profile(request):
if request.method == 'POST':
form = UserProfileForm(request.POST, instance=request.user.profile)
form.save()
else:
# user:request.user
# profile =user.profile
form = UserProfileForm(instance=request.user.profile)
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('user.html', args)
def user_profile(request):
user = request.user
profile = user.profile
# TODO: delete avatar pic after user update
if request.method == "POST":
form = UserProfileForm(
request.POST,
request.FILES,
instance=profile,
)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/profile/')
else:
form = UserProfileForm(instance=profile)
context = {}
context.update(csrf(request))
context['form'] = form
context['profile'] = profile
return render(request, 'userprofile/profile.html', context)
def edit(request):
if request.method == 'POST': # If the form has been submitted...
form = UserProfileForm(request.POST) # A form bound to the POST data
if form.is_valid():
userprofile = UserProfile()
userprofile.user = request.user
userprofile.firstname = form.cleaned_data['firstname']
userprofile.lastname = form.cleaned_data['lastname']
userprofile.number = form.cleaned_data['number']
userprofile.serie = form.cleaned_data['serie']
userprofile.sexe = form.cleaned_data['sexe']
userprofile.phoneNumber = form.cleaned_data['phoneNumber']
userprofile.save()
return redirect('userprofile.views.display') # Redirect after POST
else:
return render(request, 'userprofile/userprofile_edit.html', {
'form': form,
})
else:
try:
userprofile = UserProfile.objects.get(pk=request.user)
form = UserProfileForm({
'firstname': userprofile.firstname,
'lastname': userprofile.lastname,
'number': userprofile.number,
'serie': userprofile.serie,
'sexe': userprofile.sexe,
'phoneNumber': userprofile.phoneNumber,
})
except Exception as ex:
print ex
form = UserProfileForm()
return render(request, 'userprofile/userprofile_edit.html', {
'form': form,
})
def userprofile(request):
# update user profile submit
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
user_profile = UserProfileForm(request.POST, request.FILES, instance=request.user.profile)
if user_form.is_valid() and user_profile.is_valid():
user_form.save()
user_profile.save()
return HttpResponseRedirect(reverse('profile:user'))
else:
# shows form with user profile's details
user_form = UserForm(instance=request.user,
initial={
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'email': request.user.email,
})
user = request.user
profile = user.profile
user_profile = UserProfileForm(instance=profile)
return render(request, 'userprofile/profile.html', {'user_form': user_form, 'user_profile': user_profile})
def update(request):
data = {}
if request.POST:
try:
userprofile_form = UserProfileForm(request.POST, request.FILES, prefix='userprofile_form', instance=request.user.userprofile)
except ObjectDoesNotExist:
userprofile_form = UserProfileForm(request.POST, request.FILES, prefix='userprofile_form')
user_form = UserUpdateForm(request.POST, request.FILES, prefix='user_form', instance=request.user)
if all([userprofile_form.is_valid(), user_form.is_valid()]):
user = user_form.save()
profile = userprofile_form.save(commit=False)
profile.user = user
profile.save()
return redirect(reverse("userprofile:update"))
else:
user_form = UserUpdateForm(instance=request.user, prefix='user_form')
try:
userprofile_form = UserProfileForm(prefix='userprofile_form', instance=request.user.userprofile)
except ObjectDoesNotExist:
userprofile_form = UserProfileForm(prefix='userprofile_form')
data['userprofile_form'] = userprofile_form
data['user_form'] = user_form
return render(request, "update.html", data)
def userprofile_register(request):
# Like before, get the request's context.
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 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.
data_with_username = request.POST
data_with_username['username'] = data_with_username['email']
user_form = UserForm(data=data_with_username)
profile_form = UserProfileForm(data=data_with_username)
# 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()
user.is_staff = True
#my stuff
#g = Group.objects.get(name='normal_users')
#g.user_set.add(user)
# 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:
user_form.errors, profile_form.errors
#CHECK: had print next to above line
#------------ log em in---
email = request.POST['email']
password = request.POST['password']
user = authenticate(email=email, password=password)
if user:
# Is the account active? It could have been disabled.
if user.is_active:
# If the account is valid and active, we can log the user in.
# We'll send the user back to the homepage.
login(request, user)
#-------------------------
# 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_to_response(
'userprofile_register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered},
context)
def test_form_renders_field_inputs(self):
form = UserProfileForm()
self.fail(form.as_p())
def register(request):
# create flag for successful registration
registered = False
# if submitted, process form
if request.method == 'POST':
# grab information from forms
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
payment_form = PaymentForm(data=request.POST)
# if those are valid, continue
if user_form.is_valid() and profile_form.is_valid(
) and payment_form.is_valid():
# save user form to database
user = user_form.save()
# hash password and send to user object
user.set_password(user.password)
# save user
user.save()
# prepare userprofile form
profile = profile_form.save(commit=False)
# connect userprofile with user
profile.user = user
# if profile picture provided, save it
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
# save userprofile
profile.save()
# Do same thing for payment as profile
payment = payment_form.save(commit=False)
payment.user = user
payment.save()
# flag successful registration
registered = True
# else forms invalid, print errors
else:
print(user_form.errors, profile_form.errors)
# else show the registration form
else:
user_form = UserForm()
profile_form = UserProfileForm()
payment_form = PaymentForm()
# Render the template depending on the context.
return render(
request, 'userprofile/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'payment_form': payment_form,
'registered': registered
})
