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_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':
# 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(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():
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':
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 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 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, 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 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 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 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):
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 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_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 profile_update(request):
if request.method == 'POST':
form = ProfileUpdateForm(request.POST, instance=request.user.profile)
else:
form = ProfileUpdateForm(instance=request.user.profile)
if form.is_valid():
form.save()
context = {'form': form}
return render(request, 'users/update_profile.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)
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 profile(request):
if request.method == 'POST':
u_form=UserUpdateForm(request.POST,instance=request.user)
p_form=ProfileUpdateForm(request.POST,request.FILES,instance=request.user)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
return redirect('profile')
else:
u_form=UserUpdateForm(instance=request.user)
p_form=ProfileUpdateForm(instance=request.user)
context={'u_form':u_form,'p_form':p_form}
return render(request,'users/profile.html',context)
def test_old_images_are_deleted_on_profile_update(self):
with self.testing_media():
# https://stackoverflow.com/a/34276961
img = self.create_image()
img2 = self.create_image('testing2.png')
self.data['image'] = img
form = ProfileUpdateForm(instance=self.profile, data=self.data)
self.assertTrue(form.is_valid())
form.save()
image_path = pathlib.Path(
os.path.join(settings.MEDIA_ROOT, 'profile_pics/test.png'))
self.assertTrue(image_path.is_file())
# Update data and user profile with new image
self.data['image'] = img2
form = ProfileUpdateForm(instance=self.profile, data=self.data)
self.assertTrue(form.is_valid())
form.save()
self.assertFalse(image_path.is_file()) # old image should be gone
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, 'Your account has been updated.')
return redirect('users-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)
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 profile has been updated!')
return redirect('profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
my_dict = {'u_form': u_form, 'p_form': p_form}
return render(request, 'users/profile.html', context=my_dict)
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):
if request.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,
message=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, template_name='users/profile.html', context=context)
def profile(request):
if request.method == "POST":
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
u_form = UserUpdateForm(request.POST, instance=request.user)
if u_form.is_valid() and p_form.is_valid():
u_form.save()
p_form.save()
messages.success(
request, "{}'s profile has been updated!".format(request.user))
return redirect("users: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 updateProfile(request):
if request.method == 'POST':
u_form = UpdateForm(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 successfully!')
return redirect('profile')
else:
u_form = UpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
context = {'u_form': u_form, 'p_form': p_form}
return render(request, "update.html", context)
def account(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('/my-account/')
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, 'eventFinderApp/account.html', context)
def editprofile(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()
return redirect("user-profile", username=request.user.username)
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, "feed/editprofile.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()
username = request.user
messages.success(
request, f'Success! {username}, you Profile 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, 'title': 'Profile'}
return render(request, 'users/profile.html', context)
def edit_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, 'Profile updated successfully.')
return redirect('edit-profile')
else:
u_form = UserUpdateForm(instance=request.user)
p_form = ProfileUpdateForm(instance=request.user.profile)
return render(request, 'users/edit-profile.html', {
'u_form':u_form,
'p_form':p_form
})
