def profile(request):
"""Show user profile, allow them to update it."""
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('index'))
if request.method == 'POST':
form = UserUpdateForm(request.POST or None, instance=request.user)
if form.is_valid():
form.save()
if 'profile_image' in request.FILES:
try:
lbwuser = request.user.lbwuser
lbwuser.profile_image = request.FILES['profile_image']
lbwuser.save()
except LbwUser.DoesNotExist:
lbwuser = LbwUser(user=request.user,
profile_image=request.FILES['profile_image'])
lbwuser.save()
return redirect('index')
else:
try:
lbwuser = request.user.lbwuser
except LbwUser.DoesNotExist:
lbwuser = LbwUser(user=request.user)
lbwuser.save()
form = UserUpdateForm(instance=request.user)
return render(request, 'accounts/profile.html',
{'form': form})
def test_no_username(self):
User.objects.create_user(username='******',
email='*****@*****.**')
form = UserUpdateForm({'email': '*****@*****.**'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['username'], ['This field is required.'])
def update_view(request):
contact_form = ContactForm()
if request.user.is_authenticated:
user = request.user
if request.method == 'POST':
form = UserUpdateForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user.city = data['city']
user.language = data['language']
user.send_email = data['send_email']
user.save()
messages.success(request, 'Данные сохраненны.')
return redirect('accounts:update')
form = UserUpdateForm(
initial={
'city': user.city,
'language': user.language,
'send_email': user.send_email
})
return render(request, 'accounts/update.html', {
'form': form,
'contact_form': contact_form
})
else:
return redirect('accounts:login')
def test_invalid_update_form_existing_username(self):
"""
Test an invalid form due to existing username
"""
form_data = {"username": "******", "email": ""}
form = UserUpdateForm(data=form_data)
self.assertFalse(form.is_valid())
self.assertTrue("username" in form.errors)
def test_invalid_update_form_existing_email(self):
"""
Test an invalid form due to existing email
"""
form_data = {"username": "", "email": "*****@*****.**"}
form = UserUpdateForm(data=form_data)
self.assertFalse(form.is_valid())
self.assertTrue("email" in form.errors)
def test_invalid_update_form_username_symbols(self):
"""
Test an invalid form due to @ in username
"""
form_data = {"username": "******", "email": ""}
form = UserUpdateForm(data=form_data)
self.assertFalse(form.is_valid())
self.assertTrue("username" in form.errors)
def post(self, request, *args, **kwargs):
form = UserUpdateForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, 'Successfully updated account details')
return redirect('dashboard')
else:
messages.warning(request, 'Check you details')
return redirect('account')
def post(self, request, *args, **kwargs):
user_form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save() and profile_form.save()
messages.success(request, f"Your account has been updated!")
return redirect("bookstore")
def post(self, request, *args, **kwargs):
author_form = AuthorForm(request.POST,
request.FILES,
instance=request.user.author)
user_form = UserUpdateForm(request.POST, instance=request.user)
if author_form.is_valid() and user_form.is_valid():
user_form.save()
author_form.save()
return redirect("accounts_update")
def user_update(request, user_slug):
if request.method == "POST" and user_slug == request.user.slug:
form = UserUpdateForm(request.POST)
user = get_object_or_404(User, slug=user_slug)
if form.is_valid():
email = request.POST.get('email')
new_password = request.POST.get('new_password')
repeat_password = request.POST.get('repeat_password')
current_password = request.POST.get('current_password')
# check if email already exists
if User.objects.filter(
email=email).exists() and email != user.email:
messages.error(request,
'This email is already taken, try another.')
return redirect('accounts:user_update', user_slug=user_slug)
#check password
if user.check_password(current_password):
#check if password is to be updated
if new_password != '':
if new_password == repeat_password:
user.set_password(new_password)
else:
print('new password : {}, repeat: {}'.format(
new_password, repeat_password))
messages.error(
request,
'New password repeated incorrectly, try again.')
return redirect('accounts:user_update',
user_slug=user_slug)
#save email
user.email = email
user.save()
messages.success(request,
'Credentials were updated successfuly.')
# log in user with new credentials
user = authenticate(request,
username=email,
password=new_password)
login(request, user)
return redirect('accounts:user_home', user_slug=user_slug)
else: # wrong password
messages.error(request, 'Wrong Password')
return redirect('accounts:user_update', user_slug=user_slug)
else: # invalid form
messages.error(request, 'Ups. Something went wrong.')
return redirect('accounts:user_home', user_slug=user_slug)
else:
form = UserUpdateForm(initial={
'email': request.user.email,
})
return render(request, 'accounts/user_update.html', {
'user_update_form': form,
})
def post(request):
update_form = UserUpdateForm(request.POST, instance=request.user)
if update_form.is_valid():
update_form.save()
messages.success(request, u'个人信息已更新')
return HttpResponseRedirect(reverse('accounts:detail'))
else:
messages.error(request, u'信息更新失败')
return render(request, "accounts/form_tpl.html",
{"form": update_form})
def test_valid_update_form(self):
"""
Test a valid form
"""
form_data = {
"username": "",
"email": "*****@*****.**"
}
form = UserUpdateForm(data=form_data)
self.assertTrue(form.is_valid())
def post(self, request, username):
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST, request.FILES,
instance=request.user.profile)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(request, _('Account successfully updated!'))
return redirect('accounts:profile:bio', self.get_username())
return self.get(request, username)
def UserProfileUpdateView(request, pk):
userprofile = UserProfile.objects.get(pk=pk)
user = userprofile.user
user_form = UserUpdateForm()
user_profile_form = UserProfileUpdateForm()
if request.POST:
user_form = UserUpdateForm(request.POST, instance=user)
user_profile_form = UserProfileUpdateForm(request.POST,
instance=userprofile)
if user_form.is_valid() and user_profile_form.is_valid():
user_form.save()
user_profile_form.save()
return HttpResponseRedirect(reverse('home'))
user_form = UserUpdateForm(instance=user)
user_profile_form = UserProfileUpdateForm(instance=userprofile)
return render(request, 'userprofile/update.html', {
'user_form': user_form,
'user_profile_form': user_profile_form,
})
def employee_update_view(request, id):
data = dict()
employee_instance = Employee.objects.get(id=id)
if request.method == 'POST':
user_form = UserUpdateForm(request.POST,
initial={
'username':
employee_instance.user.username,
'email': employee_instance.user.email
})
employee_form = EmployeeForm(request.POST,
request.FILES,
instance=employee_instance)
if employee_form.is_valid() and user_form.is_valid():
username = user_form.cleaned_data.get("username")
email = user_form.cleaned_data.get("email")
user_qs = User.objects.filter(username=username).exclude(
id=employee_instance.user.id).exists()
if user_qs:
data['username_error'] = {
"error": "Username is already taken!"
}
return JsonResponse(data)
else:
instance_user = employee_instance.user
instance_user.username = username
if email:
instance_user.email = email
instance_user.save()
employee_form.save()
else:
data['errors'] = {
'status': 'form-invalid',
'employee_user_errors': user_form.errors,
'employee_errors': employee_form.errors
}
else:
user_form = UserUpdateForm(
initial={
'username': employee_instance.user.username,
'email': employee_instance.user.email
})
employee_form = EmployeeForm(instance=employee_instance)
context = {
'user_form': user_form,
'employee_form': employee_form,
'object': employee_instance
}
if request.is_ajax():
data['html_form'] = render_to_string('employees/employee-form.html',
context,
request=request)
return JsonResponse(data)
return render(request, 'employees/employee-update.html', context)
def update_user(request):
"""Register new users"""
active_user = request.user
# check if a form was submitted
if request.method == 'POST':
next = request.POST.get('next', '/')
user_form = UserUpdateForm(request.POST, instance=active_user)
if user_form.is_valid():
user = user_form.save()
else:
return redirect('accounts:profile')
return redirect(next)
def put(self, request, id=None):
context = {}
student = get_object_or_404(Student, id=id)
user = get_object_or_404(User, id=student.user.id)
user_form = UserUpdateForm(request.POST, instance=user)
student_form = StudentForm(request.POST, instance=student)
if user_form.is_valid():
get_user = user_form.save(commit=False)
if student_form.is_valid():
student_form.save(user=get_user.id, commit=False)
context = {'user_form': user_form, 'student_form': student_form}
return render(request, 'accounts/student_new_update.html', context)
def test_form_is_valid(self):
post_dict = {
'username':'******',
'email':'*****@*****.**',
}
files_dict = {
'icon':SimpleUploadedFile(
name='sample.jpeg',
content=open(os.path.join(os.environ['HOME'],'Pictures/sample.jpeg'), 'rb').read(),
content_type='image/jpeg'
)
}
form = UserUpdateForm(post_dict, files_dict)
self.assertTrue(form.is_valid())
def profile_view(request):
if request.method == 'POST':
user_form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.userprofileinfo)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile = profile_form.save(commit=False)
user = user_form.save()
user.email = profile.email
user.save()
profile.save()
messages.success(request, 'Your profile is successfully updated!')
return redirect('profile')
else:
messages.error(request, user_form.errors)
messages.error(request, profile_form.errors)
else:
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileUpdateForm(instance=request.user.userprofileinfo)
return render(request, 'accounts/profile.html', {
'user_form': user_form,
'profile_form': profile_form
})
def MasterUserUpdateView(request,slug):
masteruser_user = get_object_or_404(UserModel,slug = slug)
user_update_form = UserUpdateForm(request.POST or None, instance = masteruser_user)
masteruser = get_object_or_404(MasterUserModel, user = masteruser_user)
masteruser_update_form = MasterUserUpdateForm(request.POST or None, instance = masteruser)
if masteruser_update_form.is_valid() and user_update_form.is_valid():
user_update_form.save()
masteruser_update_form.save()
if 'picture' in request.FILES:
masteruser.picture = request.FILES['picture']
masteruser.save()
return HttpResponseRedirect(reverse('masteruser:profile',
kwargs={'slug':masteruser_user.slug}))
return render(request,'masteruser/masteruserupdate.html',
{'masteruserform':masteruser_update_form,
'userform':user_update_form,})
def get(self, request, username):
u_form = UserUpdateForm(instance=self.request.user)
p_form = ProfileUpdateForm(instance=self.request.user.profile)
context = {
'forms': [u_form, p_form],
}
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
super().get(request, *args, **kwargs)
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileUpdateForm(instance=request.user.profile)
context = {"user_form": user_form, "profile_form": profile_form}
return render(request, self.template_name,
self.get_context_data(**context))
def profile_edit_view(request):
if request.user.is_anonymous:
return redirect("accounts:login")
if request.method == 'POST':
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
update_form = UserUpdateForm(request.POST, instance=request.user)
if profile_form.is_valid() and update_form.is_valid():
if not request.user.profile.profile_img:
request.user.profile.profile_img = 'default.jpg'
profile_form.save()
update_form.save()
return redirect('/profile/' + request.user.username)
else:
profile_form = ProfileForm(instance=request.user.profile)
update_form = UserUpdateForm(instance=request.user)
context = {'profile_form':profile_form,
'update_form':update_form }
return render(request, 'accounts/profile_edit.html', context)
def bank_view(request):
try:
cart = Cart.objects.get(user=request.user.id, active=True)
items = CartItem.objects.filter(cart=cart)
except ObjectDoesNotExist:
cart = Cart.objects.create(user=request.user)
items = CartItem.objects.filter(cart=cart)
total = cart.total
if request.method == "POST":
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
return redirect('zarinpal:request')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
context = {
'u_form': u_form,
'p_form': p_form,
'cart': items,
'total': total
}
return render(request, 'cart/bank.html', context)
def update_user_profile(request):
user = User.objects.get(email=request.user.email)
#forms to update user profile
if request.method == 'POST':
user_form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request,'Your account has been updated!')
return redirect('profile')
else:
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileUpdateForm(instance=request.user.profile)
context = {
'user_form': user_form,
'profile_form': profile_form,
'user': user
}
return render(request, 'update_profile.html', context)
def user_profile(request):
'''The user profile page'''
if request.method == "POST":
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(request, "Your account has been updated")
return redirect('profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
context = {'u_form': u_form, 'p_form': p_form}
# Gettting user object
user = User.objects.get(email=request.user.email)
# Gettting profile object through foreign key
return render(request, 'profile.html', {
'profile': user,
'u_form': u_form,
'p_form': p_form
})
def update_profile(request, slug):
profile = Profile.objects.get(slug=slug)
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=profile)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
new_slug = request.POST.get('slug')
messages.success(request, f'User information has been updated!')
# return reverse("accounts:profile", kwargs={"slug": slug})
return HttpResponseRedirect(
reverse('accounts:profile', args=[new_slug]))
else:
print("user errors:", u_form.errors.as_data())
print("profile errors:", p_form.errors.as_data())
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=profile)
context = {
'p_form': p_form,
'u_form': u_form,
'categories': Category.objects.all()
}
return render(request, 'accounts/profile_update.html', context)
def ProfileView(request):
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(
request.POST, request.FILES, instance=request.user.profile)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(
request, 'Your account has been updated')
return redirect('memberships:dashboard')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
courses = Course.objects.order_by('start_date').all()[:3]
instructors = Instructor.objects.order_by('dofb').all()[:3]
context = {
'u_form': u_form,
'p_form': p_form,
'courses': courses,
'instructors': instructors
}
return render(request, 'accounts/profile.html', context)
def update_profile(request):
"""Esta função exibe ou edita um perfil de um usuário, a depender do método da requisição"""
# Tenta obter o objeto com a pk informado. Se não conseguir, retorna um erro 404
profile = get_object_or_404(Profile, user=request.user)
# Se o usuário mandar dados, ou seja, se a requisição for POST
if request.method == "POST":
# Instancia um formulário vinculado a um objeto Turma com os dados recebidos da requisição POST
form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=profile)
if form.is_valid() and profile_form.is_valid():
form.save()
profile_form.save()
# Retorna para a página de lista de turmas
return redirect("dashboard:view_dashboard")
# Se o usuário apenas solicitar para acessar a página, ou seja, se a requisição for GET
else:
# Cria uma instância com os dados do objeto passado como parâmetro
form = UserUpdateForm(instance=request.user)
profile_form = ProfileForm(instance=profile)
context = {"form": form, "profile_form": profile_form, "link": "profile"}
# Renderiza a página de editar turma com os campos e seus respectivos dados
return render(request, "dashboard/profile.html", context)
def update_user_profile(request, username):
user = User.objects.all()
for i in user:
if i.username == username:
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=i)
p_form = CreateUserProfile(request.POST,
request.FILES,
instance=i.userprofile)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(request,
f'Your accounts has been updated!')
return redirect('user_list')
else:
u_form = UserUpdateForm(instance=i)
p_form = CreateUserProfile(instance=i.userprofile)
context = {
'u_form': u_form,
'p_form': p_form,
'user': user,
'i': i,
}
return render(request, 'accounts/update_user_profile.html',
context)
def profile(request):
articles = Article.objects.filter(status=1).order_by('-date_posted')[:2]
if request.method == 'POST':
user_form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, f'Your account has been updated!')
return redirect('profile')
else:
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileUpdateForm(instance=request.user.profile)
context = {
'title': 'Profile',
'articles': articles,
'user_form': user_form,
'profile_form': profile_form,
}
return render(request, 'accounts/profile.html', context)
def profile(request):
"""
Return the user's profile page. Allows editing the profile,
as well as the login details for a user.
"""
if request.method == 'POST':
user_form = UserUpdateForm(request.POST, initial={'username': ''}, instance=request.user)
profile_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, f'Your account has been updated!')
return redirect('profile')
else:
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileUpdateForm(instance=request.user.profile)
context = {
'user_form': user_form,
'profile_form': profile_form
}
return render(request, 'accounts/profile.html', context)
def UserProfileUpdateView(request, pk):
userprofile = UserProfile.objects.get(pk=pk)
user = userprofile.user
user_form = UserUpdateForm()
user_profile_form = UserProfileUpdateForm()
if request.POST:
user_form = UserUpdateForm(request.POST, instance=user)
user_profile_form = UserProfileUpdateForm(request.POST, instance=userprofile)
if user_form.is_valid() and user_profile_form.is_valid():
user_form.save()
user_profile_form.save()
return HttpResponseRedirect(reverse('home'))
user_form = UserUpdateForm(instance=user)
user_profile_form = UserProfileUpdateForm(instance = userprofile)
return render(request, 'userprofile/update.html', {
'user_form': user_form,
'user_profile_form': user_profile_form,
})
