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_profile_update(self):
"""
Ensure the profile update form works for institutional and external users.
"""
test_cases = [
self.shibboleth_user,
self.guest_user,
]
for test_case in test_cases:
scw_username = '******'
uid_number = 5000001
description = 'test user'
account_status = 1
form = ProfileUpdateForm(
data={
'user': test_case.pk,
'scw_username': scw_username,
'uid_number': uid_number,
'description': description,
'account_status': account_status,
},
instance=test_case.profile,
)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(test_case.profile.scw_username, scw_username)
self.assertEqual(test_case.profile.uid_number, uid_number)
self.assertEqual(test_case.profile.description, description)
self.assertEqual(test_case.profile.account_status, account_status)
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 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_form(self):
file_path = os.path.join(settings.MEDIA_ROOT, 'default.jpg')
upload_file = open(file_path, 'rb')
data = {
'image': SimpleUploadedFile(upload_file.name, upload_file.read())
}
form = ProfileUpdateForm(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_profile_form_valid(self):
data = {
'image':self.user.profile.image,
'user':self.user.id
}
# if instance is not supplied will throw "Profile with user already exists" error so it will fail
# print(self.user)
form = ProfileUpdateForm(data=data, instance=self.user.profile)
# print(form)
self.assertTrue(form.is_valid())
form_obj = form.save()
self.assertIsInstance(form_obj, Profile)
def test_profile_update_form_is_valid(self):
im = Image.new(mode='RGB',
size=(200, 200)) # create a new image using PIL
im_io = BytesIO() # a BytesIO object for saving image
im.save(im_io, 'JPEG') # save the image to im_io
im_io.seek(0) # seek to the beginning
image = InMemoryUploadedFile(im_io, None, 'random-name.jpg',
'image/jpeg', len(im_io.getvalue()), None)
self.assertEquals(ProfileUpdateForm.Meta.model, Profile)
file_dict = {'user_photo': image}
form = ProfileUpdateForm(file_dict)
self.assertTrue(form.is_valid())
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 setUp(self):
self.client = Client()
self.user = h.create_user()
self.profile = self.user.profile
data = {}
# Populate profile with data
data['name'] = 'Giselle'
data['about'] = 'Important member of the team.'
data['image'] = h.create_dummy_image('test.png')
data['role'] = 'Arms expert'
form = ProfileUpdateForm(instance=self.profile, data=data)
form.save()
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 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):
#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_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_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 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':
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):
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 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 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):
"""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 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 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':
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':
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':
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 test_valid_form(self):
'''valid post data should redirect the expected behavior is to show the image'''
self.client.login(username='******', password='******')
formdata = {}
with open('purbeurre/media/profile_pics/remy.png', 'rb') as f:
formdata['image'] = f
response = self.client.post(reverse('profile'), formdata)
p_form = ProfileUpdateForm(f)
self.assertEqual(response.status_code, 302)
def settings(request):
joined_date = request.user.date_joined
format_date = joined_date.strftime('%d/%m/%Y')
update_account_form = AccountUpdateForm(instance=request.user)
update_password_form = PasswordChangeForm(user=request.user)
update_profile_form = ProfileUpdateForm(instance=request.user.profile)
modal = 'none'
# this generates forms for updating the users account details, password, and profile information
if request.method == 'POST':
print(request.POST)
if 'update_account' in request.POST:
update_account_form = AccountUpdateForm(data=request.POST, instance=request.user)
modal = 'update_account'
if update_account_form.is_valid():
update_account_form.save()
messages.success(request, f'Account details successfully updated!')
return redirect('tracker-settings')
if 'update_password' in request.POST:
update_password_form = PasswordChangeForm(data=request.POST, user=request.user)
modal = 'update_password'
if update_password_form.is_valid():
update_password_form.save()
update_session_auth_hash(request, update_password_form.user)
messages.success(request, f'Password successfully changed!')
return redirect('tracker-settings')
if 'update_profile' in request.POST:
update_profile_form = ProfileUpdateForm(data=request.POST, files=request.FILES, instance=request.user.profile)
modal = 'update_profile'
if update_profile_form.is_valid():
update_profile_form.save()
messages.success(request, f'Profile successfully updated!')
return redirect('tracker-settings')
if 'clear_food' in request.POST:
Food.objects.filter(user=request.user).delete()
return redirect('tracker-settings')
if 'clear_exercise' in request.POST:
Exercise.objects.filter(user=request.user).delete()
return redirect('tracker-settings')
if 'delete_account' in request.POST:
request.user.is_active = False
request.user.save()
return redirect('users-logout')
my_exercises = Exercise.objects.filter(user=request.user)
my_foods = Food.objects.filter(user=request.user)
# the settings page displays user's information, custom foods and exercises, completed goals, and various forms
context = {
'selected': 'Settings',
'format_date': format_date,
'update_account_form': update_account_form,
'update_password_form': update_password_form,
'update_profile_form': update_profile_form,
'modal': modal,
'exercises': my_exercises,
'foods': my_foods,
}
return render(request, 'settings.html', context)
def test_profile_form_invalid(self):
form = ProfileUpdateForm(data={})
# Form gets valid as we are passing empty dict nothing bound form << -- Need to check on this
self.assertFalse(form.is_valid())
# But saving data to the model will throw and Integrity error as existing data should need to have user details too.
with self.assertRaises(IntegrityError):
form.is_valid()
form.save()
