def testEmptyFieldForm(self):
empty_first_name_form = UserUpdateForm(
data=self._createInvalidFieldData('first_name'))
self.assertFalse(empty_first_name_form.is_valid())
empty_last_name_form = UserUpdateForm(
data=self._createInvalidFieldData('last_name'))
self.assertFalse(empty_last_name_form.is_valid())
empty_phone_number_form = UserUpdateForm(
data=self._createInvalidFieldData('phone_number'))
self.assertFalse(empty_phone_number_form.is_valid())
empty_address_form = UserUpdateForm(
data=self._createInvalidFieldData('phone_number'))
self.assertFalse(empty_address_form.is_valid())
class TestsForms(TestCase):
def setUp(self):
self.form = None
def test_user_register_form_valid(self):
self.form = UserRegisterForm(
data={
'username': '******',
'email': '*****@*****.**',
'password1': 'dummypass1234',
'password2': 'dummypass1234',
})
self.assertTrue(self.form.is_valid())
self.assertEqual(str(self.form.save()), 'myusername')
def test_user_register_form_blank(self):
self.form = UserRegisterForm(data={})
self.assertFalse(self.form.is_valid())
self.assertEqual(len(self.form.errors), 4)
def test_user_update_form_valid(self):
self.test_user_register_form_valid()
self.form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**',
})
self.assertTrue(self.form.is_valid())
self.assertEqual(str(self.form.save()), 'myusername123')
def test_user_update_form_blank(self):
self.form = UserUpdateForm(data={})
self.assertFalse(self.form.is_valid())
self.assertEqual(len(self.form.errors), 2)
def create_image(self):
im_io = BytesIO()
im = Image.new(mode='RGB', size=(300, 300)).save(im_io, 'JPEG')
return InMemoryUploadedFile(im_io, None, 'test_form.jpg', 'image/jpeg',
len(im_io.getvalue()), None).open()
# BUG: test_profile_update_form_blank() would be a valid test
# becasue data["image"] is only invalid when the file is not an image
# also p_form.save() returns an django.db.utils.IntegrityError
def test_profile_update_form_valid(self):
image = self.create_image()
self.test_user_update_form_valid()
self.p_form = ProfileUpdateForm(data={'image': image})
self.assertTrue(self.p_form.is_valid())
self.assertEqual(len(self.p_form.errors), 0)
def test_UserUpdateForm_no_data(self):
"""Testing UserUpdateForm Class
- Not Successfull , form not valid"""
form = UserUpdateForm(data={})
self.assertFalse(form.is_valid())
self.assertEquals(len(form.errors), 2)
def test_UserUpdateForm_valid_data(self):
"""Testing UserUpdateForm Class - Success Valid Form"""
form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**'
})
self.assertTrue(form.is_valid())
def post(self, request):
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST, request.FILES, instance=request.user.profile)
button = request.POST.get('button')
if button == 'update':
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(request, f'Your account has benn succesfully updated')
return redirect('profile')
else:
if u_form.is_valid():
u_form.save()
messages.success(request, f'Your account has benn succesfully updated')
elif button == 'change_password':
return redirect('change-password')
def profile(request):
form = "ok"
notifications = 0
for s in NewPost_Likes_Dislikes.objects.all(). \
filter(author=request.user.username):
notifications = notifications + s.notifications
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
if u_form.is_valid():
u_form.save()
messages.success(request, 'Your account has been updated!')
return redirect('home')
else:
u_form = UserUpdateForm(instance=request.user)
return render(request, 'users/profile.html', {
'form': form,
"update_form": u_form,
"Notifications": notifications,
})
def profile(request):
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 profile 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, 'users/profile.html', context)
# messages.debug
# messages.info
# messages.success
# messages.warning
# messages.error
def profile(request):
try:
prof = request.user.profile
except:
prof = Profile(user=request.user)
prof.save()
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, f'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}
return render(request, 'users/profile.html', context)
def update_profile_view(request, username):
if not request.user.is_authenticated:
messages.add_message(request, messages.INFO,
'You need to be logged in to edit your profile. ')
instance = UserProfile.objects.get(user=request.user)
if request.method == "POST":
profile_form = ProfileUpdateForm(request.POST, instance=instance)
user_form = UserUpdateForm(request.POST, instance=request.user)
if profile_form.is_valid() and user_form.is_valid():
profile_form.save()
user_form.save()
messages.add_message(request, messages.INFO,
'Your profile was updated successfully! ')
url = reverse('users:profile', args=[request.user])
return redirect(url)
else:
messages.add_message(request, messages.INFO,
'Please correct the errors below')
else:
profile_form = ProfileUpdateForm(instance=instance)
user_form = UserUpdateForm(instance=request.user)
return render(request, 'users/userprofile_form.html', {
'profile_form': profile_form,
'user_form': user_form,
})
def profile(request):
request.session.set_expiry(600)
if request.method == 'POST':
uForm = UserUpdateForm(request.POST,
request.FILES,
instance=request.user)
pForm = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if uForm.is_valid() and pForm.is_valid():
newAccountID = pForm.cleaned_data.get('accountID')
request.user.profile.addToAccountList(newAccountID)
# getDataForAccount(newAccountID)
uForm.save()
pForm.save()
messages.success(request, f'Account successfully updated')
return redirect('profile')
# return statement in line above is to prevent user from falling to line below
# phenomenon called 'get-redirect pattern'- when u reload browser after submitting data
# post request will be duplicated.
else:
uForm = UserUpdateForm(instance=request.user)
pForm = ProfileUpdateForm(instance=request.user.profile)
context = {
'uForm': uForm,
'pForm': pForm,
'accountIDs': getAccountIDsFromModel(request.user.profile)
}
return render(request, "transactions/profile.html", context)
def profile(request):
#at POST Request
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
# check validation
if u_form.is_valid() and p_form.is_valid():
# delete previous image before adding new one.
# but the deletion will not occur if the user current image profile
# is the default image
# because we need this default image for new users.
if 'profile_pics' in Profile.objects.filter(
user=request.user).first().image.url:
Profile.objects.filter(
user=request.user).first().image.delete(False)
u_form.save()
p_form.save()
messages.success(request, 'Your data updated Successfully!')
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}
return render(request, 'users/profile.html', context)
def profile(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()
new_phone = u_form.cleaned_data.get('phone')
p_form.save()
user = Users.objects.get(user=request.user)
user.phone = new_phone
user.save()
return redirect('profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
user = get_object_or_404(User, id=request.session.get('_auth_user_id'))
request.session['user_id'] = user.id
user_type = get_object_or_404(Users, user=user)
request.session['user_type'] = user_type.user_type.id
context = {
'user_type': request.session['user_type'],
'u_form': u_form,
'p_form': p_form
}
return render(request, 'users/profile.html', context)
def profile(request):
if request.method == 'POST':
uForm = UserUpdateForm(request.POST,
request.FILES,
instance=request.user)
pForm = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if uForm.is_valid() and pForm.is_valid():
uForm.save()
pForm.save()
messages.success(request, f'Account successfully updated')
return redirect('profile')
# return statement in line above is to prevent user from falling to line below
# phenomenon called 'get-redirect pattern'- when u reload browser after submitting data
# post request will be duplicated.
else:
uForm = UserUpdateForm(instance=request.user)
pForm = ProfileUpdateForm(instance=request.user.profile)
if request.session.get(request.user.email) != None:
project = request.session.get(request.user.email)
else:
projectID = getProjectID(request.user.email)
project = getProjectName(projectID)
request.session[request.user.email] = project
context = {
'uForm': uForm,
'pForm': pForm,
'projects': project,
}
return render(request, "designthinking/profile.html", context)
def profile(request):
if request.method == 'POST':
# print(request.FILES)
data = {'success': 'success'}
profile_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
user_form = UserUpdateForm(request.POST, instance=request.user)
print(request.POST)
if request.POST.get('email'):
if user_form.is_valid():
obj = user_form.save()
data.update({'title': f'{obj.first_name} {obj.last_name}'})
return JsonResponse(data)
if profile_form.is_valid():
obj = profile_form.save()
# user_form.save()
# messages.success(request, f'Successfully updated profile')
return JsonResponse(data)
else:
profile_form = ProfileUpdateForm(instance=request.user.profile)
user_form = UserUpdateForm(instance=request.user)
cover_form = CoverPhotoForm(instance=request.user.usercover)
user_images = Feed.objects.filter(user=request.user)
return render(request, 'users/profile.html', locals())
def profile_view(request, id):
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=Profile.objects.get(pk=id).user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=Profile.objects.get(pk=id))
pmt_hst_form = PaymentHistoryForm(request.POST,
request.FILES,
instance=Profile.objects.get(pk=id).user.paymenthistory
)
if u_form.is_valid() and p_form.is_valid() and pmt_hst_form.is_valid():
u_form.save()
p_form.save()
pmt_hst_form.save()
messages.success(request, f'Patient\'s details has been updated!')
return redirect('recp-home')
else:
u_form = UserUpdateForm(instance=Profile.objects.get(pk=id).user)
p_form = ProfileUpdateForm(instance=Profile.objects.get(pk=id))
pmt_hst_form = PaymentHistoryForm(instance=Profile.objects.get(pk=id).user.paymenthistory)
context = {
'u_form': u_form,
'p_form': p_form,
'pmt_hst_form': pmt_hst_form
}
return render(request, 'recp/recp_profile_view.html', context)
def test_user_update_form_is_valid(self):
self.assertEquals(UserUpdateForm.Meta.model, User)
form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**',
})
self.assertTrue(form.is_valid())
def profile(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, f'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,
}
return render(request, "users/profile.html", context)
#kashyap7=Super@50
# kashyap=Super500
# kumar=Super400
# parmar=Super300
def edit_profile(request):
u_form = UserUpdateForm()
p_form = ProfileUpdateForm()
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
# pas_form = PasswordChangeForm(data=request.POST, user=request.user)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
# pas_form.save()
# update_session_auth_hash(request, form.user)
messages.success(request, f'Your account has been updated!')
return redirect('blog-profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
# pas_form = PasswordChangeForm(user=request.user)
context = {
'u_form':u_form,
'p_form':p_form,
# 'pas_form':pas_form
}
return render(request,'users/editprofile.html',context)
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()
if request.FILES:
user = User.objects.filter(
username=request.user.username).first()
if user.profile.image != "default_user.jpg":
__, user_image = str(user.profile.image).split("/")
# Delete an old profile image
try:
Path(settings.MEDIA_ROOT).joinpath(
str(user.profile.image)).unlink()
except:
logging.warning(
f"Cannot delete user image {str(user.profile.image)}"
)
profile_form.save()
messages.success(request, _("You account has been updated"))
return redirect("user:profile")
def test_userupdate_form_no_data(self):
form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**'
})
self.assertTrue(form.is_valid())
self.assertEquals(len(form.errors), 0)
def profile_view(request):
profile = Profile.objects.get(id=request.session['profile_id'])
if request.method == 'POST':
user_form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=profile)
character_form = CharacterForm(request.POST,
instance=profile.character)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
character_form.save()
messages.info(request, 'Zaktualizowano profil Postaci!')
return redirect('users:profile')
else:
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileUpdateForm(instance=profile)
character_form = CharacterForm(instance=profile.character)
context = {
'current_profile': profile,
'page_title': 'Profil',
'user_form': user_form,
'profile_form': profile_form,
'character_form': character_form,
}
return render(request, 'users/profile.html', context)
def profile(request):
"""Docstring"""
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(
request.POST,
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('home')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
context = {
'u_form': u_form,
'p_form': p_form,
'title': 'Profile',
}
return render(request, 'users/profile.html', context)
def post(self, request, **kwargs):
# print(request.POST) # <QueryDict: {'id': ['7'], 'username': ['aa'], 'name_cn': ['bb'], 'phone': ['13305779168']}>
# print(kwargs) # {'pk': '7'}
# print(request.body) # b'id=7&username=aa&name_cn=bb&phone=13305779168'
pk = kwargs.get("pk")
data = QueryDict(request.body).dict()
# print(data) # {'id': '7', 'username': '******', 'name_cn': 'bb', 'phone': '13305779168'}
_userForm = UserUpdateForm(request.POST)
if _userForm.is_valid():
try:
self.model.objects.filter(pk=pk).update(**data)
res = {
'code': 0,
"next_url": reverse("users:user_list"),
'result': '更新用户成功'
}
except:
res = {
'code': 1,
"next_url": reverse("users:user_list"),
'errmsg': '更新用户失败'
}
else:
# 获取所有的表单错误
# print(_userForm.errors)
res = {
'code': 1,
"next_url": reverse("users:user_list"),
'errmsg': _userForm.errors
}
return render(request, settings.JUMP_PAGE, res)
def profile_update(request, username):
classname = ClassName.objects.filter(student=request.user)
profile = Profile.objects.get(user=request.user)
active_user = User.objects.get(username=username)
# print(active_user)
# print(profile)
# print(request.user.profile)
if request.method == 'POST':
u_form = UserUpdateForm(request.POST, instance=request.user)
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
print(u_form.errors)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(request, f'User information has been updated!')
return redirect('profile')
else:
print(p_form.errors)
messages.success(request, f'Error in updating your profile!')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
context = {'u_form': u_form, 'p_form': p_form, 'class': classname}
return render(request, 'users/profile_update.html', context)
def user_view(request):
if not request.user.is_authenticated:
return redirect("login")
context = {}
if request.POST:
form = UserUpdateForm(request.POST, instance=request.user)
if form.is_valid():
form.initial = {
"email": request.POST['email'],
"username": request.POST['username'],
}
form.save()
context['success_message'] = "Updated"
else:
form = UserUpdateForm(
initial={
"email": request.user.email,
"username": request.user.username,
}
)
context['user_form'] = form
movie_posts = MoviePost.objects.filter(author=request.user)
context['movie_posts'] = movie_posts
return render(request, "users/user.html", context)
def profile(request):
if request.method == 'POST':
update_UserForm = UserUpdateForm(request.POST, instance=request.user)
update_ProfileForm = ProfileUpdateForm(
request.POST,
request.FILES,
instance=request.user.profile
)
if update_UserForm.is_valid() and update_ProfileForm.is_valid():
update_UserForm.save()
update_ProfileForm.save()
messages.success(request, 'The Account has been Updated')
return redirect('profile')
else:
update_UserForm = UserUpdateForm(instance=request.user)
update_ProfileForm = ProfileUpdateForm(instance=request.user.profile)
context = {
'update_UserForm': update_UserForm,
'update_ProfileForm': update_ProfileForm
}
return render(request, 'users/profile.html', context)
def profile(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, f'Your account has been updated!')
return redirect('profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
posts = Post.objects.all().filter(
author=request.user).order_by('-date_posted')
total_posts = posts.count()
context = {
'u_form': u_form,
'p_form': p_form,
'posts': posts,
'total_posts': total_posts,
}
return render(request, 'users/profile.html', context)
def profile(request):
if request.method == 'POST':
uForm = UserUpdateForm(request.POST,
request.FILES,
instance=request.user)
pForm = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
if uForm.is_valid() and pForm.is_valid():
uForm.save()
pForm.save()
messages.success(request, f'Account successfully updated')
return redirect('profile')
#return statement in line above is to prevent user from falling to line below
#phenomenon called 'get-redirect pattern'- when u reload browser afrer submitting data
#post request will be duplicated.
else:
uForm = UserUpdateForm(instance=request.user)
pForm = ProfileUpdateForm(instance=request.user.profile)
context = {
'uForm': uForm,
'pForm': pForm,
}
return render(request, 'transactions/profile.html', context)
def profile(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():
u_form.save()
p_form.save()
messages.success(request, f'Your account has been updated')
return redirect('profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
all_items = UserItem.objects.filter(owned_by=request.user)
unused_items = UserItem.objects.filter(owned_by=request.user,
consumed=True)
used_items = UserItem.objects.filter(owned_by=request.user, consumed=False)
context = {
'u_form': u_form,
'p_form': p_form,
'all_items': all_items,
'unused_items': unused_items,
'used_items': used_items
}
return render(request, 'users/profile.html', context)
def profile(request):
if request.method == "POST":
user_update_form = UserUpdateForm(request.POST, instance=request.user)
upload_file_form = UploadFileForm(request.POST, request.FILES)
if user_update_form.is_valid() and upload_file_form.is_valid():
if 'file' in request.FILES:
instance = Document(file=request.FILES['file'],
user=request.user)
instance.save()
user_update_form.save()
messages.success(request, 'Profile updated successfully!')
return redirect("bank-profile")
else:
user_update_form = UserUpdateForm(instance=request.user)
upload_file_form = UploadFileForm()
documents = Document.objects.filter(user=request.user)
context = {
"title": "Profile",
"user_update_form": user_update_form,
"upload_file_form": upload_file_form,
"documents": documents
}
return render(request, 'bank/profile.html', context)
def update(request):
if request.POST:
form = UserUpdateForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
return HttpResponseRedirect('.')
else:
form = UserUpdateForm(instance=request.user)
context = {
'form': form,
'have_addresses': Address.objects.filter(user=request.user, is_deleted=False).exists(),
}
return render(request, 'users/user/update.html', context)
