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 user_profile(request):
"""User's profile page with auction results and profile form to update"""
current_auctions = Auction.objects.filter(
winning_bidder=request.user.pk, auction_end_time__gte=timezone.now())
past_paid_auctions = Auction.objects.filter(
winning_bidder=request.user.pk,
auction_end_time__lt=timezone.now(),
paid=True)
past_unpaid_auctions = Auction.objects.filter(
winning_bidder=request.user.pk,
auction_end_time__lt=timezone.now(),
paid=False)
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, 'Your profile was successfully updated.')
return redirect('profile.html')
else:
messages.error(request, 'Please correct the error below.')
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(
request, 'profile.html', {
'user_form': user_form,
'profile_form': profile_form,
'current_auctions': current_auctions,
'past_paid_auctions': past_paid_auctions,
'past_unpaid_auctions': past_unpaid_auctions
})
def post(self, request, *args, **kwargs):
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return self.form_valid(form)
else:
return self.form_invalid(form)
def ModifyProfileView(request, owner):
if request.method == "POST":
if owner == "profile":
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
else:
profile_form = ProfileFormP(request.POST,
instance=request.user.profilep)
user_form = UpdateFormRegistrazione(request.POST,
instance=request.user)
if user_form.is_valid() and profile_form.is_valid():
profile_form.save()
user_form.save()
return HttpResponseRedirect('/')
else:
print("modifica profilo non valida")
user_form = UpdateFormRegistrazione()
if owner == "profile":
profile_form = ProfileForm()
else:
profile_form = ProfileFormP()
context = {"u_form": user_form, "p_form": profile_form}
return render(request, 'core/modify_profile.html', context)
def edit_profile(request):
"""
Render a form to edit the user's profile but only if user is logged in
"""
user = request.user
if request.method == "POST":
edit_user_form = UserEditProfileForm(request.POST, instance=user)
edit_profile_form = ProfileForm(request.POST,
request.FILES,
instance=user.profile)
if edit_user_form.is_valid() and edit_profile_form.is_valid():
edit_user_form.save()
edit_profile_form.save()
return redirect('view_profile', request.user.id)
else:
messages.error(request, "Please check and amend the above.")
else:
"""render user and profile forms"""
edit_user_form = UserEditProfileForm(instance=user)
edit_profile_form = ProfileForm(instance=user.profile)
return render(request, "edit_profile.html", {
"edit_user_form": edit_user_form,
"edit_profile_form": edit_profile_form
})
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 profilepage(request):
"""Displays Profile Page / Handles updating of profile"""
if request.method == 'POST':
if 'user-information' in request.POST:
user_form = UserDataForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, "User Information Updated.")
return redirect('profile')
else:
shipping_form = ShippingForm(request.POST,
instance=request.user.profile)
if shipping_form.is_valid():
shipping_form.save()
messages.success(request, "User Information Updated.")
return redirect('profile')
user_form = UserDataForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
shipping_form = ShippingForm(instance=request.user.profile)
forms = {
'UserDataForm': user_form,
'ProfileForm': profile_form,
'Shippingform': shipping_form
}
return render(request, 'profile.html', forms)
def post(self, request, *args, **kwargs):
print(request)
oldUser = User.objects.get(id=request.user.id)
user_form = UserForm(request.POST, oldUser)
profile = oldUser.userprofile
profile.user = oldUser
profile_form = ProfileForm(request.POST or None,
request.FILES or None,
instance=profile)
print(profile_form)
if profile_form.is_valid():
profile_form.save()
print('Registering : ' + str(request.user))
return render(
request, 'accounts/message_page.html', {
'header': "Signed Up!",
'details': '',
'redirect': reverse('customer:homepage')
})
else:
return render(
request, 'accounts/message_page.html', {
'header': "Error!",
'details': 'Try Again',
'redirect': reverse('customer:homepage')
})
pass
def edit_user(request):
profile = User_Profile.objects.get(User_associated=request.user)
user = User.objects.get(id=request.user.id)
# img = None
if request.method == "POST":
profileForm = ProfileForm(request.POST, instance=profile, prefix="profile_form")
userForm = UserForm(request.POST, instance=user, prefix="user_form")
# passwordForm = PasswordChangeForm(data=request.POST, user=request.user, prefix="password_form")
if profileForm.is_valid() and userForm.is_valid():
profileForm.save()
userForm.save()
# passwordForm.save()
else:
profileForm = ProfileForm(prefix="profile_form", instance=profile,
initial={"Degree": profile.Degree,
"Year_first_enrolled": profile.Year_first_enrolled,})
userForm = UserForm(prefix="user_form", instance=user,
initial={'username': user.username,
'email': user.email,
'first_name': user.first_name,
'last_name': user.last_name})
return render_to_response("accounts/settings.html",
{"profile_form": profileForm, "user_form": userForm}, context_instance=RequestContext(request))
def profile_view(request):
try:
profile = Profile.objects.get(user=request.user)
except:
return redirect('accounts:signup')
if request.user.is_authenticated:
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
try:
if request.POST['terms_and_conditions']:
profile = form.save(commit=False)
profile.terms_and_conditions = True
profile.save()
except:
profile = form.save(commit=False)
profile.terms_and_conditions = False
profile.save()
return redirect("/")
template_name = 'registration/profile.html'
context = {}
return render(request, template_name, context)
else:
return redirect('accounts:signup')
def user_profile(request):
profile = request.user.get_profile()
if request.method == "POST":
# Read params
form = ProfileForm(request.POST, instance=profile)
subscriptionform = SubscriptionForm(request.POST, instance=profile)
userform = UserForm(request.POST, instance=request.user)
if appsettings.DEMO_SERVER and request.user.username == "demo":
messages.warning(request, _("You can not change demo profile on the demo server."))
return redirect("profile")
if form.is_valid() and userform.is_valid() and subscriptionform.is_valid():
# Save changes
form.save()
subscriptionform.save()
userform.save()
# Change language
set_lang(request.user, request=request, user=request.user)
# Redirect after saving (and possibly changing language)
response = redirect("profile")
# Set language cookie and activate new language (for message below)
lang_code = profile.language
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
messages.info(request, _("Your profile has been updated."))
return response
else:
form = ProfileForm(instance=profile)
subscriptionform = SubscriptionForm(instance=profile)
userform = UserForm(instance=request.user)
social = request.user.social_auth.all()
social_names = [assoc.provider for assoc in social]
new_backends = [x for x in load_backends(BACKENDS).keys() if x == "email" or x not in social_names]
response = render_to_response(
"accounts/profile.html",
RequestContext(
request,
{
"form": form,
"userform": userform,
"subscriptionform": subscriptionform,
"profile": profile,
"title": _("User profile"),
"licenses": Project.objects.exclude(license=""),
"associated": social,
"new_backends": new_backends,
},
),
)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language)
return response
def update_profile(request):
"""
Fetch data from user and user profile and render it on the form.
Update both models.
"""
if not request.user.is_authenticated:
return redirect('login')
else:
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profiles)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, ('Your profile has been updated successfully!'))
return redirect('user_profile')
else:
messages.error(request, ('Please correct the error below.'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profiles)
context = {
'user_form': user_form,
'profile_form': profile_form,
'title': 'Update',
'profile': 'profile'
}
return render(request, 'update_profile.html', context)
def edit_profile(request):
profile = ""
UserProfiles = UserProfile.objects.all()
for prof in UserProfiles:
if request.user == prof.user:
profile = prof
if request.method == 'GET':
context = {
'profile': profile,
'form': ProfileForm(instance=profile),
}
return render(request, 'edit_profile.html', context)
elif request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
form.save()
return redirect('accounts:User_Profile')
context = {
'profile': profile,
'form': ProfileForm(instance=profile),
}
return render(request, 'edit_profile.html', context)
def register(request):
if request.method == 'POST':
u_form = UserForm(request.POST)
p_form = ProfileForm(request.POST)
if u_form.is_valid() and p_form.is_valid():
user = u_form.save()
gender = p_form.cleaned_data.get('gender')
date_of_birth = p_form.cleaned_data.get('date_of_birth')
contact_number = p_form.cleaned_data.get('contact_number')
author = AuthorProfile.objects.create(
author=user,
gender=gender,
date_of_birth=date_of_birth,
contact_number=contact_number)
p_form = ProfileForm(request.POST, instance=author)
p_form.save()
messages.success(request, 'Your account has been created!')
return redirect('login')
else:
u_form = UserForm()
p_form = ProfileForm()
context = {'u_form': u_form, 'p_form': p_form}
return render(request, 'accounts/register.html', context)
def user_profile_edit(request, pk):
user = User.objects.get(pk=pk)
if request.user != user.userprofile.user:
return render(request, 'no_permission.html')
if request.method == 'GET':
context = {
'form_user_profile': UserProfileEditForm(instance=user),
'form_profile': ProfileForm(instance=user.userprofile),
}
return render(request, 'accounts/profile_edit.html', context)
else:
form_user = UserProfileEditForm(request.POST, instance=user)
form_profile = ProfileForm(request.POST,
request.FILES,
instance=user.userprofile)
if form_user.is_valid() and form_profile.is_valid():
form_user.save()
form_profile.save()
return redirect('user profile', user.pk)
context = {
'form_user_profile': UserProfileEditForm(instance=user),
'form_profile': ProfileForm(instance=user.userprofile),
}
return render(request, 'accounts/profile_edit.html', context)
def post(self, request, *args, **kwargs):
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return self.form_valid(form)
else:
return self.form_invalid(form)
def register(request):
if request.FILES:
print('file')
if request.method == 'POST':
userForm = UserCreationForm(request.POST)
profileForm = ProfileForm(request.POST)
if userForm.is_valid() and profileForm.is_valid():
user = userForm.save()
user.refresh_from_db()
profileForm = ProfileForm(request.POST,
request.FILES,
instance=user.profile)
profileForm.full_clean()
profileForm.save()
# return redirect('accounts/login.html')
url = 'accounts/dashboard/' + str(user.username) + '/'
return redirect('http://127.0.0.1:8000/' + url, permanent=True)
else:
return HttpResponse('failed')
else:
userForm = UserCreationForm()
profileForm = ProfileForm()
context = {'userForm': userForm, 'profileForm': profileForm}
return render(request, 'accounts/signup.html', context)
def edit_profile(request):
if request.user.is_authenticated:
user = User.objects.get(email=request.user.email)
if request.method == "POST":
# user_form = UserCreationForm(request.FILES, instance=request.user)
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
print(profile_form)
if profile_form.is_valid(): # user_form.is_valid() and
# user_form.save()
profile_form.save()
messages.success(request, ('Your profile was successfully updated!'))
return render(request, 'profile.html', {'profile_form': profile_form}) # 'user_form': user_form,
else:
messages.error(request, 'forms not valid')
# profile_form = ProfileForm()
else:
# user_form = UserCreationForm(request.FILES, instance=request.user)
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
return render(request, 'edit_profile.html', {
# 'user_form': user_form,
'profile_form': profile_form
})
else:
return redirect('login')
def update_user_details(request):
"""
Form to update user details
"""
if request.method == "POST":
user_form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
return redirect(reverse("userarea:index"))
else:
messages.error(request, user_form.errors)
messages.error(request, profile_form.errors)
else:
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return redirect(reverse("userarea:index"))
def profile(request):
form = ProfileForm(request.POST or None, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, PROFILE_MESSAGE)
return redirect(reverse('accounts:profile'))
context = {'form': form}
return render(request, 'accounts/profile.html', context)
def profile(request):
u = request.user
p = u.get_profile()
if request.method == 'POST':
previous_email = u.email
user_form = UserUpdateForm(request.POST, instance=u)
profile_form = ProfileForm(request.POST, request.FILES, instance=p)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
# Check if email change was requested
# Note: request.POST['email'] should be safe below since it's a valid email
if u.email != request.POST['email']:
p.new_email = request.POST['email']
p.email_change_key = random_string(16)
p.save()
send_email(
"Action required to change your email at TempSurge",
"accounts/emails/email_change", settings.FROM_EMAIL,
p.new_email, {
'change_email_url':
"http://tempsurge.com/accounts/change-email/" +
str(u.id) + "/" + p.email_change_key
})
return render(
request, "accounts/message.html", {
'app':
"accounts",
'connotation':
"warning",
'message':
"Please check your email (%s) and follow the reactivation instructions."
% p.new_email
})
messages.success(request,
"Your profile has been successfully updated.",
extra_tags="profile_updated")
return redirect("/accounts/profile/")
else:
user_form = UserUpdateForm(instance=u)
profile_form = ProfileForm(instance=p)
return render(
request, 'accounts/profile.html', {
'user': u,
'profile': p,
'user_form': user_form,
'profile_form': profile_form,
'random': random_string()
})
def profile_edit(request):
from django.utils.translation import ugettext as _
if request.method == 'POST':
form = ProfileForm(request.user, request.POST)
if form.is_valid():
form.save()
raise RedirectException(redirect(request), notice_message=_(u'Changes to profile saved.'))
else:
form = ProfileForm(request.user)
return {'form': form}
def profile(request):
if request.method == "POST":
form = ProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
messages.success(request, "Akun Anda berhasil di update!")
return redirect("home:home")
else:
form = ProfileForm(instance=request.user.profile)
return render(request, "accounts/update_profile.html", {"form": form})
def profile_edit(request: HttpRequest):
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, "profile edited!!")
redirect("/")
else:
form = ProfileForm(instance=request.user)
return render(request, "accounts/profile_edit_form.html", {"form": form})
def profile_form(request):
user = request.user
profile = request.user.p2puprofile
form = ProfileForm(instance=profile, initial={'first_name':user.first_name, 'last_name':user.last_name})
if request.method == 'POST':
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
return redirect('project_form')
return direct_to_template(request, 'profile_form.html', locals())
def profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, 'Your Profile has been Updated!')
return redirect('accounts:profile')
else:
form = ProfileForm(instance=request.user)
return render(request, 'accounts/profile.html', {'form': form})
def edit_profile(request):
profile = request.user.profile
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
form.save()
messages.info(request, 'Profile updated.')
return redirect(reverse('accounts:my-profile'))
else:
form = ProfileForm(instance=profile)
return render(request, 'registration/edit_profile.html', {'form': form})
def user_profile(request):
profile = Profile.objects.get(user=request.user)
form = ProfileForm(instance=profile)
if request.method == 'POST':
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
messages.success(request,'Profile updated successfully')
form = ProfileForm(instance=profile)
return render( request, 'accounts/profile-update.html', context={'form':form})
def profile_edit(request):
from django.utils.translation import ugettext as _
if request.method == 'POST':
form = ProfileForm(request.user, request.POST)
if form.is_valid():
form.save()
raise RedirectException(
redirect(request),
notice_message=_(u'Changes to profile saved.'))
else:
form = ProfileForm(request.user)
return {'form': form}
def change_profile(request):
profile = UserProfile.objects.get(user=request.user)
form = ProfileForm(instance=profile)
if request.method == 'POST':
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
form = ProfileForm(instance=profile)
return render(request,
'accounts/user_profile.html',
context={'profile_form': form})
def get(self, request, *args, **kwargs):
form = ProfileForm(request.POST or None, instance=self.request.user)
if form.is_valid():
form.save()
return redirect('dashboard')
context = self.get_context_data(**kwargs)
context['form'] = form
return self.render_to_response(context)
def model_profile_upload(request):
try:
profile = request.user.profile
except Profile.DoesNotExist:
profile = Profile(user=request.user)
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
form.save()
return redirect('profile')
else:
form = ProfileForm(instance=profile)
return render(request, 'model_profile_upload.html', {'form': form})
def user_profile(request):
profile = request.user.get_profile()
if request.method == "POST":
# Read params
form = ProfileForm(request.POST, instance=profile)
subscriptionform = SubscriptionForm(request.POST, instance=profile)
userform = UserForm(request.POST, instance=request.user)
if form.is_valid() and userform.is_valid() and subscriptionform.is_valid():
# Save changes
form.save()
subscriptionform.save()
userform.save()
# Change language
set_lang(request.user, request=request, user=request.user)
# Redirect after saving (and possibly changing language)
response = HttpResponseRedirect(reverse("profile"))
# Set language cookie and activate new language (for message below)
lang_code = profile.language
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
messages.info(request, _("Your profile has been updated."))
return response
else:
form = ProfileForm(instance=profile)
subscriptionform = SubscriptionForm(instance=profile)
userform = UserForm(instance=request.user)
response = render_to_response(
"profile.html",
RequestContext(
request,
{
"form": form,
"userform": userform,
"subscriptionform": subscriptionform,
"profile": profile,
"title": _("User profile"),
"licenses": Project.objects.exclude(license=""),
},
),
)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language)
return response
def update_profile(request):
if request.method == 'POST':
profile_form = ProfileForm(data=request.POST,
instance=request.user.profile)
if profile_form.is_valid():
profile_form.save()
return HttpResponseRedirect(reverse('accounts:profile'))
else:
print(profile_form.errors)
else:
profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'accounts/update_profile.html',
{'profile_form': profile_form})
def Edycja(request):
if request.method == 'POST':
form = ProfileForm(
request.POST, request.FILES, instance=request.user.profil
) # request.FILES is show the selected image or file
if form.is_valid():
form.save()
return redirect('profil')
else:
form = ProfileForm(instance=request.user.profil)
return render(request, 'edit_profil.html', {'form': form})
def register(request):
"""
Registration
A view to render the user registration page
"""
if request.method == "POST":
registration_form = UserRegistrationForm(request.POST)
profile_form = ProfileForm()
if registration_form.is_valid():
registration_form.save()
entered_username = registration_form.cleaned_data.get('username')
entered_password = registration_form.cleaned_data.get('password2')
user = auth.authenticate(username=entered_username,
password=entered_password)
"""
Load profile form with instance based on user instance
"""
profile_form = ProfileForm(request.POST,
request.FILES,
instance=user.profile)
profile_form.save()
if user:
messages.success(
request, "You have successfully created an account. "
"Please log in using your credentials.")
return redirect(reverse('login'))
elif (registration_form.cleaned_data.get('password2') !=
registration_form.cleaned_data.get('password1')):
"""
Provide specific error message for non-matching passwords
"""
messages.error(request, "Your passwords do not match")
else:
"""
All other error messages will be displayed in the form. As the
form may exceed display height produce generic message at bottom
of page directing users to review errors on form.
"""
messages.error(request, "Please check and amend the above.")
else:
registration_form = UserRegistrationForm()
profile_form = ProfileForm()
return render(request, "register.html", {
'registration_form': registration_form,
'profile_form': profile_form
})
def profile_edit(request):
if request.method == 'POST':
user_form = MyUserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
files=request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
return HttpResponseRedirect(reverse('accounts:profile_details'))
else:
user_form = MyUserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
context = {'user_form': user_form, 'profile_form': profile_form}
return render(request, 'accounts/profile_edit.html', context)
def update_profile(request):
if request.method == 'POST':
form = EditProfileForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=request.user.userprofile)
if form.is_valid() and profile_form.is_valid():
form.save()
profile_form.save()
return redirect('/profile')
else:
form = EditProfileForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.userprofile)
return render(request, 'accounts/edit_profile.html', {
'form': form,
'profile_form': profile_form
})
def edit(request):
profile = request.user.profile
def is_selected(prefix):
if request.method == "POST":
for name in request.POST.keys():
if name.startswith(prefix + '-'):
return True
if request.FILES:
for name in request.FILES.keys():
if name.startswith(prefix + '-'):
return True
return False
if is_selected("profile"):
profile_form = ProfileForm(request, request.POST, instance=profile, prefix="profile")
if profile_form.is_valid():
profile_form.save()
return HttpResponseRedirect(reverse("accounts-home"))
else:
profile_form = ProfileForm(request,instance=profile, prefix="profile")
if is_selected("image"):
image_form = AvatarForm(request.POST, request.FILES, prefix="image")
if image_form.is_valid():
if image_form.cleaned_data["remove"]:
profile.has_avatar = False
profile.save()
else:
handle_uploaded_image(profile, image_form.cleaned_data["file"])
profile.has_avatar = True
profile.save()
return HttpResponseRedirect(reverse("accounts-home"))
else:
image_form = AvatarForm(prefix="image")
return render_to_response('accounts/edit.html', dict(profile=profile, profile_form=profile_form, image_form=image_form), context_instance=RequestContext(request))
def save_profile(request):
title = "Edit My Profile"
icon = "edit"
if request.POST.get('save_changes'):
form = ProfileForm(data=request.POST, files=request.FILES, instance=request.user.profile)
if form.is_valid():
if request.POST.get('username', request.user.username) != request.user.username:
# change username
try:
check = User.objects.get(username=request.POST.get('username'))
messages.error(request, 'That username has already been taken!')
return locals()
except User.DoesNotExist:
request.user.username = request.POST.get('username')
request.user.save()
form.save()
request.user.first_name = request.POST.get('first_name', request.user.first_name)
request.user.last_name = request.POST.get('last_name', request.user.last_name)
request.user.save()
messages.success(request, 'Your profile has been updated!')
else:
messages.error(request, 'Unable to save changes to your profile!')
return locals()
return view_profile(request)
def user_profile(request):
profile = request.user.get_profile()
if request.method == 'POST':
# Read params
form = ProfileForm(
request.POST,
instance=profile
)
subscriptionform = SubscriptionForm(
request.POST,
instance=profile
)
userform = UserForm(
request.POST,
instance=request.user
)
if (form.is_valid()
and userform.is_valid()
and subscriptionform.is_valid()):
# Save changes
form.save()
subscriptionform.save()
userform.save()
# Change language
set_lang(request.user, request=request, user=request.user)
# Redirect after saving (and possibly changing language)
response = HttpResponseRedirect(reverse('profile'))
# Set language cookie and activate new language (for message below)
lang_code = profile.language
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
messages.info(request, _('Your profile has been updated.'))
return response
else:
form = ProfileForm(
instance=profile
)
subscriptionform = SubscriptionForm(
instance=profile
)
userform = UserForm(
instance=request.user
)
response = render_to_response('profile.html', RequestContext(request, {
'form': form,
'userform': userform,
'subscriptionform': subscriptionform,
'profile': profile,
'title': _('User profile'),
}))
response.set_cookie(
settings.LANGUAGE_COOKIE_NAME,
profile.language
)
return response
