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_UserUpdateForm_valid_data(self):
"""Testing UserUpdateForm Class - Success Valid Form"""
form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**'
})
self.assertTrue(form.is_valid())
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 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 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 test_userupdate_form_no_data(self):
form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**'
})
self.assertTrue(form.is_valid())
self.assertEquals(len(form.errors), 0)
def test_valid_user_update_form(self):
self.client.login(username='******', password='******')
new_photo.image = SimpleUploadedFile(name='testimage.png', content=open(
users/tests/testdata/testimage.png, 'rb').read())
form = UserUpdateForm(newPhoto.image)
self.assertTrue(form.is_valid())
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_form_is_valid(self):
form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**'
})
self.assertTrue(form.is_valid())
def test_user_profile_update_form_invalid(self):
form = UserUpdateForm(
data = {
'image' :""
}
)
self.assertFalse(form.is_valid())
def test_user_update_form_valid_data(self):
form = UserUpdateForm(data={
'username': '******',
'email': '*****@*****.**'
})
self.assertTrue(form.is_valid())
print('user update form valid data pass')
def test_valid_user_update_form(self):
self.client.login(username='******', password='******')
data = {
'image': ''
}
form = UserUpdateForm(data=data)
self.assertFalse(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)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
return redirect('profile')
def test_form(self):
data = {
'username': '******',
'email': '*****@*****.**',
}
form = UserUpdateForm(data)
self.assertTrue(form.is_valid())
def test_user_update_form_invalid(self):
form = UserUpdateForm(
data = {
'username' :"user2",
'email' : ""
}
)
self.assertFalse(form.is_valid())
def test_user_update_form_valid(self):
form = UserUpdateForm(
data = {
'username' :"user2",
'email' : "*****@*****.**"
}
)
self.assertTrue(form.is_valid())
def test_profile_form_valid_email(self):
form_data = {
'username': self.base_user.username,
'email': '*****@*****.**'
}
form = UserUpdateForm(instance=self.base_user, data=form_data)
assert form.is_valid() == True
def post(self, request):
user_info_form = UserUpdateForm(request.POST, instance=request.user)
if user_info_form.is_valid():
user_info_form.save()
return HttpResponse('{"status":"success"}',
content_type='application/json')
else:
return HttpResponse(json.dumps(user_info_form.errors),
content_type='application/json')
def post(self, request, *args, **kwargs):
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 was updated.')
return redirect('profile')
def test_update_userdata_is_not_valid(self):
""" function testing that username and email are not valid"""
self.client.login(username='******', password='******')
form_data2 = {'username': '',
'email': 'jacob123ail.com',
}
u_form = UserUpdateForm(form_data2)
self.assertFalse(u_form.is_valid())
response = self.client.post(reverse('profile'), form_data2)
self.assertTemplateUsed(response, 'users/profile.html')
def test_valid_user_update_form(self):
self.client.login(username='******', password='******')
data = {
'username': '******',
'email': '*****@*****.**'
}
form = UserUpdateForm(data=data)
self.assertTrue(form.is_valid())
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 test_user_update_form(self):
data = {
'email':self.user.email,
'first_name':'Ravi',
'last_name' :'Kumar'
}
form = UserUpdateForm(data=data, instance=self.user)
# print(form.errors)
self.assertTrue(form.is_valid())
form.save()
self.assertTrue(SnetUser.objects.get(id=self.user.id).first_name=='Ravi')
def test_update_userdata_is_valid(self):
""" function testing that username and email are updated"""
self.client.login(username='******', password='******')
u_form = UserUpdateForm(self.form_data)
u_form.save()
response = self.client.post(reverse('profile'), self.form_data)
self.assertTrue(u_form.is_valid())
self.user.username = '******'
self.user.email = '*****@*****.**'
self.assertContains(response, 'jacob123')
self.assertContains(response, '*****@*****.**')
self.assertEqual(response.status_code, 200)
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 post(self, request, *args, **kwargs):
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'Account has been updated successfully!')
return redirect('profile')
else:
context = {'u_form': u_form, 'p_form': p_form}
return render(request, self.template_name, context)
def create_or_update_phone_number(request):
form_class = PhoneNumberForm
user = get_object_or_404(User, pk=request.user.id)
if request.method == "POST":
form = form_class(request.POST, request.FILES)
if form.is_valid():
try:
old_number = PhoneNumber.objects.get(user=user)
new_number = form['number'].value()
old_number.number = str(new_number)
old_number.twilio_formatted_number = format_twilio_number(
str(new_number))
old_number.created_date = timezone.now()
old_number.is_valid_phone_number = old_number.is_valid_number()
old_number.save()
except PhoneNumber.DoesNotExist:
phone_number = form.save(commit=False)
phone_number.user = user
phone_number.twilio_formatted_number = format_twilio_number(
phone_number.number)
phone_number.created_date = timezone.now()
phone_number.is_valid_phone_number = phone_number.is_valid_number(
)
phone_number.save()
return render(
request, 'users/account.html', {
'user': user,
'form': UserUpdateForm(request.POST or None, instance=user),
})
context = {
'form': form_class,
}
return render(request, 'phone_numbers/update_phone_number.html', context)
def get(self, request, *args, **kwargs):
user = request.user
user_form = UserUpdateForm(instance=user)
profile_form = ProfileUpdateForm(instance=user.profile)
# Number of approved user posts
approved = Post.objects.filter(author=user).filter(
status=Post.APPROVED).count()
# Posts under review
pending = Post.objects.filter(author=user).filter(
status=Post.PENDING).count()
# Posts declined to publication
declined = Post.objects.filter(author=user).filter(
status=Post.DECLINED).count()
context = {
"user": user,
"user_form": user_form,
"profile_form": profile_form,
"approved": approved,
"pending": pending,
"declined": declined,
}
return render(request, self.template_name, context)
def update_account(request, user_id):
user = get_object_or_404(User, pk=user_id)
if request.user.is_authenticated() and request.user.id == user.id:
form = UserUpdateForm(request.POST or None, instance=user)
context = {
'user': user,
'form': form,
}
if form.is_valid():
form.save()
return render(request, 'users/account.html', context)
else:
raise PermissionDenied
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)
def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request')
super().__init__(*args, **kwargs)
self.fields['subjects'].label = 'Vakken'
self.fields['teacher_email'].label = 'Leraar email'
self.fields['profile_picture'].label = 'Profielfoto'
self.fields['hourprice'].label = 'Uurprijs'
self.helper = FormHelper()
self.helper.layout = Layout(
TabHolder(
Tab(
'Algemeen',
HTML(
'{% load crispy_forms_tags %}{% crispy form.user_form %}'
)),
Tab(
'LeraarProfiel',
Row(
Col('teacher_email'),
Col('hourprice'),
),
Row(Col('subjects'), ),
Row(
Col(HTML(
"""{% if form.profile_picture.value %}<img class="img-responsive img-fluid rounded" src="{{ MEDIA_URL }}{{ form.profile_picture.value }}">{% endif %}""",
),
css_class='col-sm-1'),
Col('profile_picture'),
),
),
Tab('Beschikbaarheid'),
Tab('Preview'),
))
self.helper.add_input(Submit("submit", "Update profiel"))
if self.request.method == 'GET':
self.user_form = UserUpdateForm(instance=self.request.user)
else:
self.user_form = UserUpdateForm(
data=self.request.POST,
instance=self.request.user,
initial={
field: getattr(self.request.user, field)
for field in UserUpdateForm.Meta.fields
})
