def edit_user(request):
"""
Display forms for edit user
**Context**
user
set password form
notification
**Template:**
:template:`edit_user.html`
"""
user = User.objects.get(id=request.user.id)
form = PasswordChangeForm(None)
notification = None
if request.method == 'POST':
if request.POST.get('changePassword'):
form = PasswordChangeForm(user, request.POST)
if form.is_valid():
form.save()
notification = 'Hasło zostało zmienione! :)'
update_session_auth_hash(request, form.user)
elif request.POST.get('changeColor'):
embigo_user = EmbigoUser.objects.get(user=user)
embigo_user.color = request.POST.get('color')
embigo_user.save()
notification = 'Zmieniono kolor avatara! :)'
context = {
'user': request.user,
'form': form,
'notification': notification
}
return render(request, 'edit_user.html', context)
def my_profile_view(request):
''' The view of the profile page. '''
page_name = "Profile Page"
if request.user.username == ANONYMOUS_USERNAME:
return red_home(request, MESSAGES['SPINELESS'])
user = request.user
userProfile = UserProfile.objects.get(user=request.user)
change_password_form = PasswordChangeForm(
request.user,
request.POST if "submit_password_form" in request.POST else None,
)
update_profile_form = UpdateProfileForm(
request.POST if "submit_profile_form" in request.POST else None,
user=request.user,
initial={
'former_houses': userProfile.former_houses,
'email': user.email,
'email_visible_to_others': userProfile.email_visible,
'phone_number': userProfile.phone_number,
'phone_visible_to_others': userProfile.phone_visible,
},
)
if change_password_form.is_valid():
change_password_form.save()
messages.add_message(request, messages.SUCCESS, "Your password was successfully changed.")
return HttpResponseRedirect(reverse('my_profile'))
if update_profile_form.is_valid():
update_profile_form.save()
messages.add_message(request, messages.SUCCESS, "Your profile has been successfully updated.")
return HttpResponseRedirect(reverse('my_profile'))
return render_to_response('my_profile.html', {
'page_name': page_name,
'update_profile_form': update_profile_form,
'change_password_form': change_password_form,
}, context_instance=RequestContext(request))
def user_profile(request):
profile, created = UserProfile.objects.get_or_create(user=request.user)
if request.method == 'POST':
user_form = UserForm(request.POST,instance=request.user)
profile_form = UserProfileForm(request.POST,instance=profile)
password_form = PasswordChangeForm(request.user,request.POST)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
next = request.GET.get('next', '')
if next:
response = HttpResponseRedirect(next)
else:
response = HttpResponseRedirect(reverse('reviewapp.submissionlist'))
if password_form.changed_data:
if password_form.is_valid():
password_form.save()
return response
else:
return response
else:
user_form = UserForm(instance=request.user)
profile_form = UserProfileForm(instance=profile)
password_form = PasswordChangeForm(request.user)
return render_to_response('reviewapp/user_profile.html', locals(),
context_instance=RequestContext(request))
def profile(request):
user = request.user
user_profile = user.get_profile()
user_info = {
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
}
check_errors = False
if request.method == 'POST': # If a form has been submitted...
if "old_password" in request.POST: #They submitted the password change form.
account_form = UserAccountForm(user_info)
password_form = PasswordChangeForm(user, request.POST)
if password_form.is_valid():
password_form.save()
request.notifications.success(_("Password changed successfully."))
return HttpResponseRedirect(reverse('portal.main.views.profile'))
else:
check_errors = True
# If they aren't changing their email, pass that to UserAccountForm.
# This is so we can use form validation to ensure that new emails are unique. Since, if
# it's unchanged it will obviously already exist and fail validation.
if user.email == request.POST.get('email', ""):
email_changed = False
else:
email_changed = True
post = request.POST.copy()
account_form = UserAccountForm(post, email_changed=email_changed)
password_form = PasswordChangeForm(user)
if account_form.is_valid():
user.first_name = account_form.cleaned_data['first_name']
user.last_name = account_form.cleaned_data['last_name']
if email_changed:
user.email = account_form.cleaned_data['email']
user.save()
profile = user.get_profile()
profile.address1 = account_form.cleaned_data['address1']
profile.address2 = account_form.cleaned_data['address2']
profile.city = account_form.cleaned_data['city']
profile.state = account_form.cleaned_data['state']
profile.country = account_form.cleaned_data['country']
profile.phone = account_form.cleaned_data['phone']
profile.save()
request.notifications.success(_("Account information saved."))
return HttpResponseRedirect(reverse('portal.main.views.profile'))
else:
account_form = UserAccountForm(user_info)
password_form = PasswordChangeForm(user)
return render_to_response("main/profile.html", {
"user_profile": user_profile,
"account_form": account_form,
"password_form": password_form,
"check_errors": check_errors,
}, context_instance=RequestContext(request))
def profile(request):
if request.method == "POST":
userform = UserForm(request.POST, instance=request.user)
passwordform = PasswordChangeForm(request.user, request.POST)
error = False
if userform.has_changed() and userform.is_valid():
userform.save()
elif not userform.has_changed():
userform = UserForm(instance=request.user)
else:
error = True
if passwordform.has_changed() and passwordform.is_valid():
passwordform.save()
elif not passwordform.has_changed():
passwordform = PasswordChangeForm(user=request.user)
else:
error = True
if not error:
redirect('login')
else:
userform = UserForm(instance=request.user)
passwordform = PasswordChangeForm(user=request.user)
ctx = {
'userform': userform,
'passwordform': passwordform,
}
return render(request, 'profile.html', ctx)
def change_profile(request, old_password=None, new_password=None, new_email=None, bio=None):
if bio is not None:
request.user.userinfo.bio_text = bio
request.user.userinfo.save()
request.user.details.force()
if new_email is not None:
if not User.validate_email(new_email):
raise ValidationError({'new_email': "Please enter a valid email address."})
if request.user.email != new_email:
if not User.email_is_unused(new_email):
raise ValidationError({'new_email': "Sorry! That email address is already being used for an account."})
request.user.email = new_email
request.user.save()
request.user.details.force()
if old_password is not None and new_password is not None:
if not User.validate_password(new_password):
raise ValidationError({
'new_password': "******"
"Please use {} or more characters.".format(User.MINIMUM_PASSWORD_LENGTH),
})
form = PasswordChangeForm(user=request.user, data={
'old_password': old_password,
'new_password1': new_password,
'new_password2': new_password,
})
api_forms.validate(form)
form.save()
request.user.details.force()
def change_password(request):
if not password_management_enabled():
raise Http404
can_change_password = request.user.has_usable_password()
if can_change_password:
if request.method == 'POST':
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
form.save()
update_session_auth_hash(request, form.user)
messages.success(request, _("Your password has been changed successfully!"))
return redirect('wagtailadmin_account')
else:
form = PasswordChangeForm(request.user)
else:
form = None
return render(request, 'wagtailadmin/account/change_password.html', {
'form': form,
'can_change_password': can_change_password,
})
def profile_settings(request):
if request.method == 'POST':
if 'password-old_password' in request.POST:
pass_form = PasswordChangeForm(data=request.POST, user=request.user, prefix='password')
if pass_form.is_valid():
pass_form.save()
messages.success(request, _('Пароль успешно изменен'))
return redirect('account_settings')
else:
pass_form = PasswordChangeForm(user=request.user, prefix='password')
if 'settings-timezone' in request.POST:
form = UserSettingsForm(data=request.POST, instance=request.user, prefix='settings')
if form.is_valid():
form.save()
messages.success(request, _('Данные профиля успешно обновлены'))
return redirect('account_settings')
else:
form = UserSettingsForm(instance=request.user, prefix='settings')
else:
form = UserSettingsForm(instance=request.user, prefix='settings')
pass_form = PasswordChangeForm(user=request.user, prefix='password')
return render(request, 'default_set/settings.html',
dict(form=form, pass_form=pass_form)
)
def profile(request):
profileform = None
passwordform = None
if request.method == 'POST':
if 'update-profile' in request.POST:
profileform = ProfileForm(request.POST, instance=request.user)
if profileform.is_valid():
profileform.save()
messages.success(request, 'Profile updated successfully.')
return redirect('profile')
elif 'update-password' in request.POST and not settings.EXTERNAL_AUTH:
passwordform = PasswordChangeForm(user=request.user, data=request.POST)
if passwordform.is_valid():
passwordform.save()
messages.success(request, 'Password updated successfully.')
return redirect('profile')
if not profileform:
profileform = ProfileForm(None, instance=request.user)
if not passwordform and not settings.EXTERNAL_AUTH:
passwordform = PasswordChangeForm(None)
return render(request, 'accounts/profile.html', {
'profileform': profileform,
'passwordform': passwordform,
})
def change_password(self, request):
'''
更改用户密码接口.
``POST`` `account/change_passwrod/ <http://192.168.1.222:8080/v1/account/change_password>`_
:param old_password:
旧密码
:param new_password:
新密码
'''
user = request.user
old_password = request.POST.get("old_password")
new_password = request.POST.get("new_password")
data = {
"old_password": old_password,
"new_password1": new_password,
"new_password2": new_password,
}
form = PasswordChangeForm(user=user, data=data)
if form.is_valid():
form.save()
# Send a signal that the password has changed
userena_signals.password_complete.send(sender=None,
user=user)
return rc.accepted({"result": True})
# return form.error_messages
return rc.BAD_REQUEST
def usersettings(request, template_name='usersettings/usersettings.html'):
"""Render a Users settings page.
If this is the first time a user is visting the settings page,
a default settings instance is created for this user.
"""
try:
profile = request.user.get_profile()
except models.UserSettings.DoesNotExist:
s = models.UserSettings(user=request.user)
s.save()
profile = request.user.get_profile()
if request.method == "POST":
userform = forms.UserForm(data=request.POST, instance=request.user)
passform = PasswordChangeForm(request.user, data=request.POST)
settingsform = forms.UserSettingsForm(data=request.POST, instance=profile)
if userform.is_valid():
userform.save()
if passform.is_valid():
passform.save()
if settingsform.is_valid():
settingsform.save()
redirect = request.POST.get("referer")
return HttpResponseRedirect(redirect)
else:
referer = urlparse(request.META.get('HTTP_REFERER', '')).path
if referer == '':
referer = "/bookshelf/"
userform = forms.UserForm(instance=request.user)
passform = PasswordChangeForm(request.user)
settingsform = forms.UserSettingsForm(instance=profile)
tmpl_args = {'userform':userform, 'passform':passform, 'settingsform':settingsform, 'user':request.user, 'referer':referer}
return render_to_response(template_name, tmpl_args)
def change_pwd(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('../login/')
#superuser = request.user.is_superuser
views = request.session.get('view', {})
fav = request.session.get('fav', [])
cname = "密码修改"
if request.method == "POST":
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
form.save()
success = "密码修改完成"
try:
log_id = "%s%05d" % (datetime.datetime.now().strftime("%Y%m%d%H%M%S"),random.randint(0,10000))
log = "change_pwd|"
tolog(request,log,log_id)
except:
pass
return render_to_response('change_pwd.html', {'success':success,
'form': form,
'cname':cname,
'views': views,
'fav':fav,
'version':WEB2_VERSION,
},context_instance=RequestContext(request))
else:
form = PasswordChangeForm(request.user)
return render_to_response('change_pwd.html', {'form': form,
'cname': cname,
'views': views,
'fav':fav,
'version':WEB2_VERSION,
},context_instance=RequestContext(request))
def profile(request):
form = UserForm(instance=request.user)
pwd_form = PasswordChangeForm(request.user)
associations = {'twitter': False, 'google_oauth2': False, 'github': False}
for association in request.user.social_auth.all():
associations[association.provider.replace('-', '_')] = True
if request.method == 'POST':
if request.POST.get('do_password'):
pwd_form = PasswordChangeForm(request.user, request.POST)
if pwd_form.is_valid():
pwd_form.save()
messages.success(request, "Password successfully changed.")
else:
messages.error(request, "Could not update password. See errors below.")
elif request.POST.get('do_profile'):
form = UserForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, 'Profile successfully updated.')
else:
messages.error(request, 'You have an error in your profile. See below errors.')
else:
messages.error(request, "Er, something weird happened. Contact the site admin.")
return render(request, 'accounts/profile.html', locals())
def form_valid(self, form):
form = PasswordChangeForm(user=self.request.user,
data=self.request.POST)
if form.is_valid():
form.save()
update_session_auth_hash(self.request, form.user)
return HttpResponseRedirect(reverse('password_change_done'))
def view_edit_passwd(request,id):
try:
u = User.objects.get(id=id)
if request.method == "POST":
form = PasswordChangeForm(u,request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect("/alumno/")
else:
form = PasswordChangeForm(u)
msg="Revisa bien los datos"
ctx = {'form':form,'msg':msg}
return render_to_response('alumno/passwd.html',ctx,
context_instance=RequestContext(request))
else:
form = PasswordChangeForm(u)
msg="Ingresa los datos"
ctx = {'form':form,'msg':msg}
return render_to_response('alumno/passwd.html',ctx,
context_instance=RequestContext(request))
except ObjectDoesNotExist:
ctx = {'msg':"No se encontro el alumno solicitado"}
return render_to_response('msg.html',ctx,
context_instance=RequestContext(request))
def my_profile_view(request):
""" The view of the profile page. """
page_name = "Profile Page"
if request.user.username == ANONYMOUS_USERNAME:
return red_home(request, MESSAGES["SPINELESS"])
userProfile = UserProfile.objects.get(user=request.user)
change_password_form = PasswordChangeForm(
request.user, request.POST if "submit_password_form" in request.POST else None
)
update_email_form = UpdateEmailForm(
request.POST if "submit_profile_form" in request.POST else None, instance=request.user, prefix="user"
)
update_profile_form = UpdateProfileForm(
request.POST if "submit_profile_form" in request.POST else None, instance=userProfile, prefix="profile"
)
if change_password_form.is_valid():
change_password_form.save()
messages.add_message(request, messages.SUCCESS, "Your password was successfully changed.")
return HttpResponseRedirect(reverse("my_profile"))
if update_email_form.is_valid() and update_profile_form.is_valid():
update_email_form.save()
update_profile_form.save()
messages.add_message(request, messages.SUCCESS, "Your profile has been successfully updated.")
return HttpResponseRedirect(reverse("my_profile"))
return render_to_response(
"my_profile.html",
{
"page_name": page_name,
"update_email_form": update_email_form,
"update_profile_form": update_profile_form,
"change_password_form": change_password_form,
},
context_instance=RequestContext(request),
)
def post(self, request, *args, **kwargs):
form = PasswordChangeForm(self.form_class(request.POST))
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('pharmacies:pharmacy'))
self.initial['errors'] = form.errors
return HttpResponseRedirect(reverse('pharmacies:change'))
def account_settings(request):
password_change_form = PasswordChangeForm(request.user)
nick_change_form = NickChangeForm(request.user)
email_change_form = EmailChangeForm(request.user)
form = request.POST.get('form')
if form == 'change_pw':
password_change_form = PasswordChangeForm(request.user, request.POST)
if password_change_form.is_valid():
password_change_form.save()
messages.success(request, _("Password was changed."))
return redirect('registration_account')
elif form == 'change_nick':
nick_change_form = NickChangeForm(request.user, request.POST)
if nick_change_form.is_valid():
nick_change_form.save()
messages.success(request, _('Your nickname is now {}.').format(
nick_change_form.cleaned_data['nickname']))
return redirect('registration_account')
elif form == 'change_email':
email_change_form = EmailChangeForm(request.user, request.POST)
if email_change_form.is_valid():
return _verify_email(request,
email_change_form.cleaned_data['email'])
return TemplateResponse(request, 'registration/account.html', {
'password_change_form': password_change_form,
'nick_change_form': nick_change_form,
'email_change_form': email_change_form,
'username': request.user.username,
})
def edit_profile_password(request, form=None):
"""
Used to give Dajax(ice) the change password page
Renders in : modal
Refreshes : right_content
"""
dajax = Dajax()
errors = False
userprofile = request.user.get_profile()
fullname = userprofile.user.get_full_name()
nickname = userprofile.nickname
if request.method == 'POST' and form != None:
form = PasswordChangeForm(userprofile.user, deserialize_form(form))
if form.is_valid():
form.save()
dajax.remove_css_class('#profile_edit_form input', 'error')
dajax.script('modal_hide()') # Hide modal
show_alert(dajax, 'success', 'Password was changes successfully')
else:
errors = True
dajax.remove_css_class('#profile_edit_form input', 'error')
for error in form.errors:
dajax.add_css_class('#id_%s' % error, 'error')
print "errors :", [i for i in form.errors]
#show_alert(dajax, 'error', "There were errors in the form") # as it is in modal, not req
else:
form = PasswordChangeForm ( userprofile.user )
html_content = render_to_string("users/passwd_form.html", locals(), RequestContext(request))
dajax.assign("#id_modal", "innerHTML", html_content) # Populate modal
return dajax.json()
def edit_settings(request):
if request.method == 'POST':
if 'change_settings' in request.POST:
old_email = request.profile.settings.email
settings_form = SettingsForm(
request.POST, instance=request.profile.settings)
if settings_form.is_valid():
settings_obj = settings_form.save()
if settings_obj.email != old_email:
send_new_address_email(settings_obj)
messages.info(request, MESSAGES['email_updated'])
else:
messages.info(request, MESSAGES['settings_changed'])
return redirect(edit_settings)
elif 'change_password' in request.POST:
password_form = PasswordChangeForm(request.user, request.POST)
if password_form.is_valid():
password_form.save()
messages.info(request, MESSAGES['password_changed'])
return redirect(edit_settings)
if 'change_settings' not in request.POST:
settings_form = SettingsForm(instance=request.profile.settings)
if 'change_password' not in request.POST:
password_form = PasswordChangeForm(request.user)
return locals()
def profile(request):
""" Edit profile settings """
profile = UserProfile.objects.get(user=request.user)
if 'email' in request.POST:
form = ProfileForm(request.POST)
if form.is_valid():
form.save_email(profile.user)
form.save_phone(profile)
return HttpResponseRedirect('?')
else:
form = ProfileForm()
form.initial.update({
'email': profile.user.email,
'phone': profile.phone_number,
})
if 'old_password' in request.POST:
form_p = PasswordChangeForm(request.user, request.POST)
if form_p.is_valid():
form_p.save()
return HttpResponseRedirect('?pc=1')
else:
form_p = PasswordChangeForm(request.user)
return {
'user': request.user,
'form': form,
'form_p': form_p,
'title': 'Settings',
'profile': profile,
'updated_pass': request.GET.get('pc'),
}
def change_profile(request, username):
if username != request.user.get_username():
return HttpResponseForbidden
old_email = get_object_or_404(User, username=username).email
profile_change_form = ProfileChangeForm(prefix='profile',
initial={'email': old_email})
passwd_change_form = PasswordChangeForm(username, prefix='passwd')
if request.method == 'POST':
if any(['profile' in key for key in request.POST.keys()]):
profile_change_form = ProfileChangeForm(request.POST, prefix='profile')
if profile_change_form.is_valid():
user = request.user
user.email = profile_change_form.cleaned_data['email']
user.save()
if any(['passwd' in key for key in request.POST.keys()]):
passwd_change_form = PasswordChangeForm(data=request.POST,
user=request.user, prefix='passwd')
if passwd_change_form.is_valid():
passwd_change_form.save()
auth.update_session_auth_hash(request, passwd_change_form.user)
return render(request, 'profile_change.html', {'form_profile': profile_change_form,
'form_passwd': passwd_change_form})
def user_preferences(request):
""" Displays user preferences
"""
profile = UserPreference.objects.get_or_create(user=request.user)[0]
if request.POST:
if "password_change" in request.POST:
password_form = PasswordChangeForm(user=request.user, data=request.POST)
form = UserPreferenceForm(instance=profile)
if password_form.is_valid():
password_form.save()
messages.success(request, 'Your password has been successfully changed.')
update_session_auth_hash(request, password_form.user)
elif "prefs_change" in request.POST:
form = UserPreferenceForm(request.POST, instance=profile)
password_form = PasswordChangeForm(user=request.user)
if form.is_valid():
form.cleaned_data['user'] = request.user
form.save()
messages.info(request, 'Successfully updated preferences')
if 'refer' in request.GET and request.GET['refer']:
return HttpResponseRedirect(request.GET['refer'])
return HttpResponseRedirect(reverse('admin:index'))
else:
form = UserPreferenceForm(instance=profile)
password_form = PasswordChangeForm(user=request.user)
return render_to_response('sis/user_preferences.html', {
'form': form,
'password_form': password_form,
}, RequestContext(request, {}),)
def settings(request):
if not request.user.customer:
return HttpResponseRedirect(reverse('admin_index'))
password_change_form = PasswordChangeForm(request.user)
settings_form = SettingsForm(instance=request.user)
if request.POST:
form = request.POST.get('form')
if form == 'password_change':
logger.info('%s is trying to change password' % request.user)
password_change_form = PasswordChangeForm(user = request.user,
data = request.POST)
if password_change_form.is_valid():
password_change_form.save()
logger.info('Password changed succesfully')
password_change_form = PasswordChangeForm(request.user)
else:
logger.info('Password not changed')
elif form == 'settings':
logger.info('%s is trying to change settings' % request.user)
settings_form = SettingsForm(instance = request.user,
data = request.POST)
if settings_form.is_valid():
settings_form.save()
logger.info('Settings changed succesfully')
else:
logger.info('Settings not succesfully')
context_dictionary = {
'password_change_form': password_change_form,
'settings_form': settings_form,
}
return render(request, 'settings.html', context_dictionary)
def lk(request):
c = get_common_context(request)
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
user_profile = request.user.get_profile()
c['form'] = ProfileLKForm(instance=user_profile)
c['passform'] = PasswordChangeForm(request.user)
if request.method == 'POST':
if request.POST.get('action', '') == 'data':
form = ProfileLKForm(request.POST, instance=user_profile)
u = request.user
if form.is_valid():
form.save()
c['form'] = form
if request.POST.get('action', '') == 'password':
passform = PasswordChangeForm(request.user, request.POST)
if passform.is_valid():
passform.save()
messages.success(request, u'Вы успешно сменили пароль.')
return HttpResponseRedirect('/edu/cabinet/')
else:
c['passform'] = passform
c['title'] = u'Личный кабинет'
return render_to_response('lk.html', c, context_instance=RequestContext(request))
def recruiter_account(request):
if request.method == "POST" and request.POST.get("password_change") == "yes":
password_form = PasswordChangeForm(request.user, data=request.POST)
if password_form.is_valid():
password_form.save()
messages.add_message(request, messages.SUCCESS, "Password changed")
else:
password_form = PasswordChangeForm(request.user)
if request.method == "POST" and request.POST.get("email_change") == "yes":
email_form = EmailChangeForm(request.POST, instance=request.user)
if email_form.is_valid():
email_form.save()
messages.add_message(request, messages.SUCCESS, "Email changed")
else:
email_form = EmailChangeForm(instance=request.user)
return render_to_response(
"corporate/resume/recruiter_account.html",
{
"section": "corporate",
"page": "account",
"account": request.user,
"password_form": password_form,
"email_form": email_form,
},
context_instance=RequestContext(request),
)
def accounts_preferences(request, template_name='accounts/preferences.html'):
user = request.user
profile = user.get_profile()
if 'password_form' in request.POST:
password_form = PasswordChangeForm(user, data=request.POST)
if password_form.is_valid():
password_form.save()
else:
password_form = PasswordChangeForm(user)
if 'email_form' in request.POST:
email_form = EmailChangeForm(request.POST, instance=user)
if email_form.is_valid():
email_form.save()
else:
email_form = EmailChangeForm(instance=user)
if 'i18n_form' in request.POST:
i18n_form = InternationalizationForm(request.POST, instance=profile)
if i18n_form.is_valid():
i18n_form.save()
else:
i18n_form = InternationalizationForm(instance=profile)
return render_to_response(template_name,
{'user': user, 'i18n_form': i18n_form,
'password_form': password_form,
'email_form' : email_form},
context_instance=RequestContext(request))
def post(self, request):
form = PasswordChangeForm(request.user, request.POST)
if not form.is_valid():
return render(request, 'account/reset-password.html',
{'form': form})
form.save()
return HttpResponseRedirect(reverse('home'))
def change_password(request):
form = PasswordChangeForm(data=request.POST or None, user = request.user)
if request.method == 'POST' and form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/my_account/')
context = RequestContext(request, {'form': form})
return render_to_response('account/change_password.html', context)
def profile(request):
'''
Viewing of signup details and editing of password
'''
context = {}
if request.method == 'POST':
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
form.save()
messages.info(request, 'Password Changed.')
else:
form = PasswordChangeForm(request.user)
key = Key.objects.get(email=request.user.email)
#analytics
endpoint_q = key.reports.values('api__name', 'endpoint').annotate(calls=Sum('calls')).order_by('-calls')
endpoints = [{'endpoint':'.'.join((d['api__name'], d['endpoint'])),
'calls': d['calls']} for d in endpoint_q]
date_q = key.reports.values('date').annotate(calls=Sum('calls')).order_by('date')
context['endpoints'], context['endpoint_calls'] = _dictlist_to_lists(endpoints, 'endpoint', 'calls')
context['timeline'] = date_q
context['form'] = form
context['key'] = key
context['password_is_key'] = request.user.check_password(key.key)
return render_to_response('locksmith/profile.html', context,
context_instance=RequestContext(request))
def passwordchange(request):
category = Category.objects.all()
setting = Setting.objects.get(pk=1)
if request.method == 'POST':
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
messages.success(request,
'Your password was successfully updated!')
return HttpResponseRedirect('/user/userprofile')
else:
messages.error(
request,
'Please correct the error below.<br>' + str(form.errors))
return HttpResponseRedirect('/user/passwordchange')
else:
form = PasswordChangeForm(request.user)
context = {
'category': category,
'setting': setting,
'form': form,
}
return render(request, 'userpasswordchange.html', context)
def settings(request):
if request.method == 'POST':
profile_form_obj = EditProfileForm(request.POST)
password_form_obj = PasswordChangeForm(request.POST)
if "profile_form" in request.POST:
profile_form_obj = EditProfileForm(request.POST, instance=request.user)
if profile_form_obj.is_valid():
user = profile_form_obj.save()
context = {'profile_form': profile_form_obj, 'password_form': password_form_obj}
return render(request, f'{app_name}/pages/settings.html', context=context)
elif 'password_form' in request.POST:
password_form_obj = PasswordChangeForm(request.user, request.POST)
if password_form_obj.is_valid():
user = password_form_obj.save()
return redirect(reverse('login'))
context = {'profile_form': profile_form_obj, 'password_form': password_form_obj}
return render(request, f'{app_name}/pages/settings.html', context=context)
else:
profile_form_obj = EditProfileForm(instance=request.user)
password_form_obj = PasswordChangeForm(request.user)
return render(request, f'{app_name}/pages/settings.html', {'profile_form': profile_form_obj, 'password_form': password_form_obj})
def change_password(request):
if request.method == 'POST':
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
sweetify.success(request,
title='Sucess'
'Your password was successfully updated!',
button='ok',
timer=5000)
# messages.success(request, '')
return redirect('Shoppy:shoppy-user_account')
else:
sweetify.error(request,
title='Error'
'Please correct the error in the form',
button='ok',
timer=5000)
# messages.error(request, '')
else:
form = PasswordChangeForm(request.user)
return render(request, 'shoppy/user_account.html', {'form': form})
def change_password(request):
if request.method == 'POST':
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
#messages.success(request, 'Your password was successfully updated!')
role=authenticate_role(user)
if(role == 'STUDENT'):
return redirect('student_dashboard')
elif (role == 'FACULTY'):
return redirect('faculty_dashboard')
elif (role =='AUDITOR'):
return redirect('auditor_profile')
elif(role == 'COORDINATOR'):
return redirect('coordinator_dashboard')
else:
messages.error(request, 'Please correct the error below.')
else:
form = PasswordChangeForm(request.user)
return render(request, 'accounts/change_password.html', {
'form': form
})
def post(self, request):
print(request.POST)
_method = request.POST.get("_method", None)
print(_method)
if _method == "update":
account_form = ProfileForm(instance=request.user,
data=request.POST)
if account_form.is_valid():
user = account_form.save()
update_session_auth_hash(request, user) # Important!
messages.success(request,
'Your account was successfully updated!')
return redirect('session:account-details')
else:
form = PasswordChangeForm(instance=request.user)
messages.error(request, 'Please correct the error below.')
return render(request, 'session/account_details.html', {
"form": form,
"account_form": account_form
})
elif _method == "password":
form = PasswordChangeForm(request.user, data=request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
messages.success(request,
'Your password was successfully updated!')
return redirect('session:account-details')
else:
account_form = ProfileForm(instance=request.user)
messages.error(request, 'Please correct the error below.')
return render(request, 'session/account_details.html', {
"form": form,
"account_form": account_form
})
def password(request):
user = request.user
if request.method == 'POST':
# Password 변경!
# 1. POST로 넘어온 data를 form에 넣기
form = PasswordChangeForm(user, request.POST)
# 2. form 유효성 검사
if form.is_valid():
# 3. 검사를 통과했다면, 저장!
user = form.save()
# 3-1. 저장 완료 후, 로그인 세션 유지!
update_session_auth_hash(request, user)
# 4. 어딘가로 돌려보내기
return redirect('accounts:edit')
else:
# Password 변경 양식 보여주기
form = PasswordChangeForm(user)
context = {
'form': form,
}
return render(request, 'accounts/password.html', context)
def change_pw_form(request):
success = request.GET.get('success', False)
if request.method == 'POST':
form_pw = PasswordChangeForm(request.user, request.POST)
if form_pw.is_valid():
user = form_pw.save()
update_session_auth_hash(request, user)
url = str(request.path_info) + str('?success=True')
return HttpResponseRedirect(url)
else:
form_pw = PasswordChangeForm(request.user)
# Checa se existe algum erro para ativar no template
form_errors = False
for field in form_pw:
if field.errors:
form_errors = True
context = {
"form_pw": form_pw,
"success": success,
"form_errors": form_errors
}
return render(request, "usuario/forms/AlterarSenha.html", context)
def change_password(request):
if request.method == 'GET':
form = PasswordChangeForm(request.user)
context = {'forms': form}
return render(request, 'change_password.html', context)
else:
form = PasswordChangeForm(request.user, request.POST)
if request.POST.get('new_password1') == request.POST.get(
'new_password2'):
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
messages.add_message(request, messages.SUCCESS,
"Your password is successfully updated!")
return redirect('change_password')
else:
messages.add_message(request, messages.ERROR,
"Password doesn't match")
return redirect('change_password')
else:
messages.add_message(request, messages.ERROR,
"Password and Confirm doesn't match")
return redirect('change_password')
def altera_senha_form(request):
senhaAlterada = False
if request.method == 'POST':
form_senha = PasswordChangeForm(request.user, request.POST)
if form_senha.is_valid():
user = form_senha.save()
update_session_auth_hash(request, user)
senhaAlterada = True
else:
messages.error(request, 'Error')
else:
form_senha = PasswordChangeForm(request.user)
erros = []
for field in form_senha:
if field.errors:
erros.append(field.errors)
if len(erros) == 0:
erros = 'none'
context = {
"form_senha": form_senha,
"senhaAlterada": senhaAlterada,
"errosFormSenha": erros
}
return render(request, "usuario/forms/AlterarSenha.html", context)
def settings_view(request):
try:
info = Member.objects.get(user=request.user)
except:
info = Member(user=request.user)
if request.method == 'POST':
info_form = MyUserSettingsForm(request.POST,
request.FILES,
instance=info)
password_form = PasswordChangeForm(request.user, request.POST)
if info_form.is_valid():
info_form = info_form.save()
if password_form.is_valid():
password_form.clean_old_password()
password_form = password_form.save()
return HttpResponseRedirect("/settings/")
else:
info_form = MyUserSettingsForm(instance=info)
password_form = PasswordChangeForm(request.user, request.GET)
return render_to_response("settings.html", {
'info_form': info_form,
'password_form': password_form,
},
context_instance=RC(request))
def changepassword(self, request):
if not request.user.is_authenticated():
logger.error(u'[UserControl]用户未登陆')
raise PermissionDenied
form = PasswordChangeForm(request.user, request.POST)
errors = []
#验证表单是否正确
if form.is_valid():
user = form.save()
oprlog = OprLog.objects.create(name='VmaigUser',
customer=request.user,
opr_type='修改',
bak='密码修改')
auth.logout(request)
else:
#如果表单不正确,保存错误到errors列表中
for k, v in form.errors.items():
#v.as_text() 详见django.forms.util.ErrorList 中
errors.append(v.as_text())
mydict = {"errors": errors}
return HttpResponse(json.dumps(mydict),
content_type="application/json")
def index(request):
template_name = 'profiles/index.html'
error = ""
if request.method == "POST" and request.POST.get('form') == "edit-profile":
form1 = forms.UserForm(data=request.POST, instance=request.user)
if form1.is_valid():
form1.save()
messages.success(request, 'Your profile was successfully updated!')
return redirect('Profile:Index')
else:
messages.error(request, 'Please correct the error below')
error = 'profile'
else:
form1 = forms.UserForm(instance=request.user)
if request.method == 'POST' and request.POST.get(
'form') == "edit-password":
form2 = PasswordChangeForm(request.user, request.POST)
if form2.is_valid():
password = form2.save()
update_session_auth_hash(request, password) # Important!
messages.success(request,
'Your password was successfully updated!')
return redirect('Profile:Index')
else:
messages.error(request, 'Please correct the error below')
error = 'password'
else:
form2 = PasswordChangeForm(request.user)
context = {
'form1': form1,
'form2': form2,
'error': error,
}
return render(request, template_name, context)
def change_password(request):
try:
template = 'system_app/merchant/password.html'
context_dict = dict()
if request.method == 'POST':
form = PasswordChangeForm(request.user, request.POST)
context_dict['form'] = form
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
messages.success(request, 'Your password was successfully updated!')
return redirect('/system/dashboard')
else:
form = PasswordChangeForm(request.user)
context_dict['form'] = form
except:
return server_error(request)
return render(request, template, context_dict)
def change_password(request):
if request.method == 'GET':
password_change_form = PasswordChangeForm(request.user)
if request.method == 'POST':
password_change_form = PasswordChangeForm(request.user, request.POST)
if password_change_form.is_valid():
user = password_change_form.save()
update_session_auth_hash(request, user)
messages.success(request, "Password Changed Successfully!")
return redirect(reverse_lazy("change_password"))
messages.error(request, "Incorrect Details!")
context = {
'password_change_form': password_change_form
}
# Manager
if request.user.is_superuser or request.user.is_manager:
return render(request, 'registration/manager_change_password.html', context=context)
#Student
return render(request, 'registration/student_change_password.html', context=context)
def change_pass(request):
socialaccount = SocialAccount.objects.all()
accounts_list = []
for i in socialaccount:
accounts_list.append(i.user.username)
if not request.user.is_authenticated or request.user.username in accounts_list:
return redirect('/')
if request.method == 'POST':
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user)
messages.success(request,
'¡Tu contraseña fué actualizada con éxito!')
return redirect('cambiar-contraseña')
else:
messages.error(
request, 'Por favor, verificá si ingresaste bien los datos.')
else:
form = PasswordChangeForm(request.user)
return render(request, 'password/change/change_pass.html', {'form': form})
def account(request):
"""
Return active subscriptions from a Stripe customer as well as the customer
and id
"""
"""
def return_subs():
customer_id = Subscription.objects.filter(user_id=request.user).first()
if customer_id:
customer_id = customer_id.customer_id
customer = stripe.Customer.retrieve(customer_id)
subscriptions = []
for sub in customer.subscriptions.data:
subscriptions.append(sub)
if customer:
# Filters out subscriptions terminated before today
active_subscriptions = [sub for sub in subscriptions if sub.created < time.time()]
for sub in active_subscriptions:
sub.created = datetime.datetime.fromtimestamp(float(sub.created))
sub.current_period_end = datetime.datetime.fromtimestamp(float(sub.current_period_end))
else:
customer = {}
active_subscriptions = {}
customer_id = None
else:
customer = {}
active_subscriptions = {}
customer_id = None
return active_subscriptions, customer, customer_id
"""
# If user has submitted change account details form
if request.method == "POST" and 'account-change-submit' in request.POST:
password_form = PasswordChangeForm(request.user)
user_form = EditProfileForm(request.POST,
instance=request.user,
user=request.user)
if user_form.is_valid():
#active_subscriptions, customer, customer_id = return_subs()
user = User.objects.get(pk=request.user.id)
user_form.save()
user = User.objects.get(pk=request.user.id)
# Update email in Stripe if customer exists
if customer_id:
stripe.Customer.modify(customer_id,
email=user_form.cleaned_data['email'])
else:
# Ensure request.user does not change based on user_form
user = User.objects.get(pk=request.user.id)
request.user = user
#active_subscriptions, customer, customer_id = return_subs()
# If user has submitted change password form
elif request.method == "POST" and 'password-change-submit' in request.POST:
user_form = EditProfileForm(instance=request.user, user=request.user)
password_form = PasswordChangeForm(request.user, request.POST)
if password_form.is_valid():
password_form.save()
update_session_auth_hash(request, password_form.user)
#active_subscriptions, customer, customer_id = return_subs()
else:
pass
#active_subscriptions, customer, customer_id = return_subs()
else:
user_form = EditProfileForm(instance=request.user, user=request.user)
password_form = PasswordChangeForm(request.user)
#active_subscriptions, customer, customer_id = return_subs()
context = {
'password_form': password_form,
'user_form': user_form,
#'customer': customer,
#'active_subscriptions': active_subscriptions
}
return render(request, 'account.html', context)
def update_profile(request):
if request.user.is_authenticated:
if request.method == 'POST' and 'profileupdatebtn' in request.POST:
user_form = UserEditForm(instance=request.user, data=request.POST)
profile_form = UserProfileForm(
instance=request.user.profile,
data=request.POST,
files=request.FILES,
)
if profile_form.is_valid() and user_form.is_valid():
profile_form.save(commit=False)
profile_form.instance.full_name = request.user.first_name + \
" " + request.user.last_name
# profile = Profile.objects.get(request.user.id)
usr_profile = Profile.objects.get(user_id=request.user.id)
profile = usr_profile.profile_image.file.name
if usr_profile.profile_image.name != "default_profile_image.png":
if os.path.exists(profile):
os.remove(profile)
user_form.save()
profile_form.save()
messages.success(request,
'Your profile is successfully updated!')
return HttpResponseRedirect(request.path)
elif request.method == 'POST' and 'updatepasswordbtn' in request.POST:
change_password = PasswordChangeForm(data=request.POST,
user=request.user)
if change_password.is_valid():
user = change_password.save()
login(request,
user,
backend='django.contrib.auth.backends.ModelBackend')
update_session_auth_hash(request, user)
messages.success(request,
'Your password is successfully updated!')
return redirect('index')
else:
user_form = UserEditForm(instance=request.user)
profile_form = UserProfileForm(instance=request.user.profile)
userdelform = RemoveUser()
return render(
request, 'SMM/update_profile.html', {
'user_form': user_form,
'profile_form': profile_form,
'change_password': change_password,
'removeuser_form': userdelform
})
elif request.method == 'POST' and 'deactivateconfirmbtn' in request.POST:
user_record = User.objects.get(id=request.user.id)
user_record.is_active = False
user_record.save()
elif request.method == 'POST' and 'deleteconfirmbtn' in request.POST:
userdelform = RemoveUser(request.POST)
if userdelform.is_valid():
delete_account(request)
return redirect('account_delete')
else:
change_password = PasswordChangeForm(user=request.user)
user_form = UserEditForm(instance=request.user)
profile_form = UserProfileForm(instance=request.user.profile)
userdelform = RemoveUser(request.POST)
return render(
request, 'SMM/update_profile.html', {
'user_form': user_form,
'profile_form': profile_form,
'change_password': change_password,
'removeuser_form': userdelform
})
return redirect('remember_me_login')
def chat_index_view(request, user_name):
_form = request.POST.get('form_name')
chat_form = RoomForm()
pwd_form = PasswordChangeForm(request.user)
if _form == 'logout_form':
# Logging out user
user = request.user
logout(request)
messages.success(request, f'User {user} is logged out')
return redirect('home')
all_rooms = Chat_room.objects.all()
user = request.user
rooms = []
for room in all_rooms:
if user == room.me or user == room.other:
rooms.append(room)
if _form == 'chat_form':
#creating a new chat room
chat_form = RoomForm(request.POST)
if chat_form.is_valid():
id_ = request.POST.get('other')
me = request.user
other = MyUser.objects.get(id=id_)
count = 0
for room in all_rooms:
if (room.me == me
and room.other == other) or (room.me == other
and room.other == me):
count += 1
print(count)
if count == 0:
Chat_room.objects.create(me=me, other=other)
messages.success(request, f'Chat {me}-{other} created .!')
return redirect('chat', user)
else:
messages.warning(request, f'Chat already exists!')
if _form == 'pwd_form':
# Changing password
pwd_form = PasswordChangeForm(request.user, request.POST)
if pwd_form.is_valid():
user = pwd_form.save()
update_session_auth_hash(request, user)
messages.success(request, f'Your password was . updated!')
return redirect('change_password')
else:
messages.warning(request,
f'Please Correct the errors on the form!...')
if _form == 'delete_form':
# Delete a chat room
_id = request.POST.get('room_id')
print(_id, request.POST.get('room_id'))
room = Chat_room.objects.get(id=_id)
room.delete()
messages.success(request,
f"Chatroom '{room.me}-{room.other}' deleted.")
return redirect('chat', user)
context = {
'pwd_form': pwd_form,
'chat_form': chat_form,
'rooms': rooms,
'user': user
}
return render(request, 'chat_index.html', context)
def usuario_perfil(request):
"""
Função para o formulário de troca de senha dos usuários do sistema
"""
perfil = get_object_or_404(Perfil, user=request.user.id)
if request.method == 'POST':
# Formulário para a alteração da senha
form = PasswordChangeForm(request.user, request.POST)
# Formulário para a alteração da quantidade de linhas por página
# da tabela Perfil
form2 = PerfilForm(request.POST, instance=perfil)
# Foi utilizada esta crítica abaixo para que não se misturasse as
# mensagens de erro da alteração de senha e da alteração da
# quantidade de linhas por página (por ser multiform)
if form.is_valid():
try:
# Altera a nova senha
user = form.save()
update_session_auth_hash(request, user)
messages.success(request, 'Senha alterada com sucesso!')
return redirect('accounts:usuario_perfil')
except:
messages.error(request, 'Não foi possível alterar a sua senha!')
elif form2.is_valid():
try:
outros = form2.save()
messages.success(request, 'Parâmetro alterado com sucesso!')
return redirect('accounts:usuario_perfil')
except:
messages.error(request, 'Não foi possível alterar o parãmetro!')
elif not form.is_valid():
# Verifica se o campo senha antiga está correto
if not request.user.check_password(request.POST.get('old_password')):
messages.error(request,
'A senha antiga digitada não é a correta!'
)
# Verifica as críticas aos campos de senha
if (request.POST.get('new_password1') !=
request.POST.get('new_password2')):
messages.error(request,
'A nova senha e sua confirmação digitada são diferentes!'
)
# Verificação do comprimento da senha com no mínimo 8 caracteres
if len(request.POST.get('new_password1')) < 8:
messages.error(request,
'A nova senha não está com o comprimento mínimo de 8 caracteres!'
)
# Verificação de pelo menos 1 letra maiúscula
if len(re.findall(r"[A-Z]", request.POST.get('new_password1'))) < 1:
messages.error(request,
'A nova senha deve possuir no mínimo 1 letra maiúscula!'
)
# Verificação de pelo menos 1 número
if len(re.findall(r"[0-9]", request.POST.get('new_password1'))) < 1:
messages.error(request,
'A nova senha deve possuir no mínimo 1 número!'
)
return redirect('accounts:usuario_perfil')
else:
form = PasswordChangeForm(request.user)
form2 = PerfilForm(instance=perfil)
return render(request, 'accounts/perfil.html', {
'form': form,
'form2': form2,
})
def password_change(request):
"""Decorative function to change password and maintain login session"""
form = PasswordChangeForm(user=request.user, data=request.POST)
if form.is_valid():
form.save()
update_session_auth_hash(request, form.user)
def settings_form(request):
if not request.user.is_anonymous:
info = get_object_or_404(
UserProfile,
pk=request.user.userprofile.pk) # user's custom profile
try:
custom_settings = Settings.objects.get(
is_the_chosen_one=True) # custom global settings
except Settings.DoesNotExist:
custom_settings = True
social_networks = get_object_or_404(
UserSocialNetworks, pk=request.user.usersocialnetworks.pk)
try:
user_permission = request.user.userprofile.role.name
except AttributeError:
user_permission = None
form_password = PasswordChangeForm(user=request.user)
form_alt_email = UserEditAltEmail(instance=info)
form_user_settings = UserEditSettingsForm(instance=info)
form_social_networks = UserEditSocialNetworksForm(
instance=social_networks)
form_invitation = InvitationForm()
try:
UserSocialAuth.objects.get(user_id=request.user.id)
except UserSocialAuth.DoesNotExist:
is_signin_social_network = False
else:
is_signin_social_network = True
if request.method == 'POST' and 'passwordedit' in request.POST and not is_signin_social_network:
form_password = PasswordChangeForm(data=request.POST,
user=request.user)
if form_password.is_valid():
form_password.save()
update_session_auth_hash(request, form_password.user)
log(user=request.user,
action='CHANGE_PASSWORD',
extra={'user_name': request.user.username})
messages.success(
request, _('Your password has been successfully changed.'))
else:
messages.error(request, _('Sorry, try again.'))
elif request.method == 'POST' and 'settingsedit' in request.POST:
form_user_settings = UserEditSettingsForm(request.POST,
instance=info)
if form_user_settings.is_valid():
form_user_settings.save()
log(user=request.user,
action='CHANGE_SETTINGS',
extra={'user_name': request.user.username})
messages.success(
request,
_('Your settings have been successfully changed.'))
else:
messages.error(request, _('Sorry, try again.'))
elif request.method == 'POST' and 'altemailedit' in request.POST:
form_alt_email = UserEditAltEmail(request.POST, instance=info)
if form_alt_email.is_valid():
info = form_alt_email.save(commit=False)
if info.user_alternative_email != request.user.userprofile.user_alternative_email:
current_site = get_current_site(request)
subject = _('Alternative email')
message = render_to_string(
'activations/acc_active_alt_email.html', {
'user':
request.user,
'domain':
current_site.domain,
'uid':
urlsafe_base64_encode(force_bytes(
request.user.pk)),
'token':
alt_email_confirmation.make_token(request.user),
'email':
info.user_alternative_email,
})
from_email = settings.EMAIL_HOST_USER
to_list = [info.user_alternative_email]
send_mail(subject,
message,
from_email,
to_list,
fail_silently=True)
messages.success(
request,
_('Check your verification code ') +
'"{}"!'.format(info.user_alternative_email))
else:
messages.warning(request, _('Enter another email.'))
else:
messages.error(request, _('You cannot enter this email.'))
elif request.method == 'POST' and 'socialnetworksedit' in request.POST:
form_social_networks = UserEditSocialNetworksForm(
request.POST, instance=social_networks)
if form_social_networks.is_valid():
form_social_networks.save()
messages.success(request, _('Done!'))
log(user=request.user,
action='CHANGE_SOCIAL',
extra={'user_name': request.user.username})
else:
messages.error(request, _('Wrong links.'))
elif request.method == 'POST' and 'verifymainemail' in request.POST:
current_site = get_current_site(request)
subject = _('Confirmation email')
message = render_to_string(
'activations/acc_active_email.html', {
'user': request.user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(request.user.pk)),
'token': account_activation_token.make_token(request.user),
})
from_email = settings.EMAIL_HOST_USER
to_list = [request.user.email]
send_mail(subject,
message,
from_email,
to_list,
fail_silently=True)
messages.success(
request,
_('Check your verification code ') +
'"{}"!'.format(request.user.email))
elif request.method == 'POST' and 'invitation' in request.POST:
form_invitation = InvitationForm(request.POST)
if form_invitation.is_valid():
invitation = form_invitation.save(commit=False)
if User.objects.filter(
username=invitation.to_user_email).first():
messages.error(request, _('This user already exists.'))
else:
invitation.from_user = request.user
invitation.save()
current_site = get_current_site(request)
subject = _('Invitation')
message = render_to_string(
'invitation/invitation_template_0.html', {
'from_user': request.user,
'to_email': invitation.to_user_email,
'domain': current_site.domain,
})
from_email = settings.EMAIL_HOST_USER
to_list = [invitation.to_user_email]
send_mail(subject,
message,
from_email,
to_list,
fail_silently=True)
messages.info(request, _('Thank you for help!'))
else:
messages.error(request, _('Fail.'))
return {
'custom_settings': custom_settings,
'user_permission': user_permission,
'form_invitation': form_invitation,
'form_password': form_password,
'form_alt_email': form_alt_email,
'form_user_settings': form_user_settings,
'form_social_networks': form_social_networks,
'is_signin_social_network': is_signin_social_network,
}
return {}
def customer_detail_change(request):
"""User Detail change on Customer UI
**Attributes**:
* ``form`` - UserChangeDetailForm, UserChangeDetailExtendForm,
PasswordChangeForm, CheckPhoneNumberForm
* ``template`` - 'frontend/registration/user_detail_change.html'
**Logic Description**:
* User is able to change his/her detail.
"""
user_detail = get_object_or_404(User, username=request.user)
try:
user_detail_extened = UserProfile.objects.get(user=user_detail)
except UserProfile.DoesNotExist:
#create UserProfile
user_detail_extened = UserProfile(user=user_detail)
#DEMO / Disable
if not settings.DEMO_MODE:
user_detail_extened.save()
user_detail_form = UserChangeDetailForm(request.user,
instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(request.user,
instance=user_detail_extened)
user_password_form = PasswordChangeForm(user=request.user)
check_phone_no_form = CheckPhoneNumberForm()
try:
dialer_set = DialerSetting.objects.get(id=request.user.get_profile().dialersetting_id)
except:
dialer_set = ''
msg_detail = ''
msg_pass = ''
msg_number = ''
error_detail = ''
error_pass = ''
error_number = ''
action = ''
if 'action' in request.GET:
action = request.GET['action']
if request.method == 'POST':
if request.POST['form-type'] == "change-detail":
user_detail_form = UserChangeDetailForm(
request.user, request.POST, instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(
request.user, request.POST, instance=user_detail_extened)
action = 'tabs-1'
if (user_detail_form.is_valid()
and user_detail_extened_form.is_valid()):
#DEMO / Disable
if not settings.DEMO_MODE:
user_detail_form.save()
user_detail_extened_form.save()
msg_detail = _('detail has been changed.')
else:
error_detail = _('please correct the errors below.')
elif request.POST['form-type'] == "check-number": # check phone no
action = 'tabs-4'
check_phone_no_form = CheckPhoneNumberForm(data=request.POST)
if check_phone_no_form.is_valid():
if not common_contact_authorization(request.user, request.POST['phone_number']):
error_number = _('this phone number is not authorized.')
else:
msg_number = _('this phone number is authorized.')
else:
error_number = _('please correct the errors below.')
else: # "change-password"
user_password_form = PasswordChangeForm(user=request.user,
data=request.POST)
action = 'tabs-2'
if user_password_form.is_valid():
#DEMO / Disable
if not settings.DEMO_MODE:
user_password_form.save()
msg_pass = _('your password has been changed.')
else:
error_pass = _('please correct the errors below.')
template = 'frontend/registration/user_detail_change.html'
data = {
'module': current_view(request),
'user_detail_form': user_detail_form,
'user_detail_extened_form': user_detail_extened_form,
'user_password_form': user_password_form,
'check_phone_no_form': check_phone_no_form,
'msg_detail': msg_detail,
'msg_pass': msg_pass,
'msg_number': msg_number,
'error_detail': error_detail,
'error_pass': error_pass,
'error_number': error_number,
'dialer_set': dialer_set,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'action': action,
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def edit_details(request):
if request.method == "POST":
# POST actions for BasicDetailsForms
try:
curr_user = models.BasicDetails.objects.get(user_name=request.user)
form = forms.BasicDetailsForm(request.POST, instance=curr_user)
if form.is_valid():
form.save()
except:
form = forms.BasicDetailsForm(request.POST)
if form.is_valid():
form = form.save(commit=False)
form.user_name = request.user
form.save()
# POST actions for PresentLocationForm
try:
curr_user = models.PresentLocation.objects.get(
user_name=request.user)
form = forms.PresentLocationForm(request.POST, instance=curr_user)
if form.is_valid():
form.save()
except:
form = forms.PresentLocationForm(request.POST)
if form.is_valid():
form = form.save(commit=False)
form.user_name = request.user
form.save()
# POST actions for Password change
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
messages.success(request,
'Your password was successfully updated!')
return redirect('change_password')
else:
messages.error(request, 'Please correct the error below.')
return redirect("profiles/edit_details.html")
else: # GET actions
try:
curr_user = models.BasicDetails.objects.get(user_name=request.user)
form1 = forms.BasicDetailsForm(instance=curr_user) # basic details
except:
form1 = forms.BasicDetailsForm()
try:
curr_user = models.PresentLocation.objects.get(
user_name=request.user)
form2 = forms.PresentLocationForm(instance=curr_user) # location
except:
form2 = forms.PresentLocationForm()
# change password
form3 = PasswordChangeForm(request.user)
dici = {"form1": form1, "form2": form2, "form3": form3}
return render(request, "profiles/edit_details.html", dici)
def update_password(req, user):
new_user = ChangePassword(req.POST, instance=user)
if new_user.is_valid():
new_user.save()
return False
return redirect(reverse("users:edit"))
def customer_detail_change(request):
"""User Detail change on Customer UI
**Attributes**:
* ``form`` - UserChangeDetailForm, UserChangeDetailExtendForm,
PasswordChangeForm, CheckPhoneNumberForm
* ``template`` - 'frontend/registration/user_detail_change.html'
**Logic Description**:
* User is able to change his/her detail.
"""
user_detail = User.objects.get(username=request.user)
try:
user_detail_extened = UserProfile.objects.get(user=user_detail)
except UserProfile.DoesNotExist:
#create UserProfile
user_detail_extened = UserProfile(user=user_detail)
#DEMO / Disable
user_detail_extened.save()
user_detail_form = UserChangeDetailForm(request.user, instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(request.user,
instance=user_detail_extened)
user_password_form = PasswordChangeForm(user=request.user)
check_phone_no_form = CheckPhoneNumberForm()
try:
user_ds = UserProfile.objects.get(user=request.user)
dialer_set = DialerSetting.objects.get(id=user_ds.dialersetting.id)
except:
dialer_set = ''
user_notification = \
notification.Notice.objects.filter(recipient=request.user)
# Search on sender name
q = (Q(sender=request.user))
if q:
user_notification = user_notification.filter(q)
msg_detail = ''
msg_pass = ''
msg_number = ''
msg_note = ''
error_detail = ''
error_pass = ''
error_number = ''
action = ''
if 'action' in request.GET:
action = request.GET['action']
if request.GET.get('msg_note') == 'true':
msg_note = request.session['msg_note']
# Mark all notification as read
if request.GET.get('notification') == 'mark_read_all':
notification_list = \
notification.Notice.objects.filter(unseen=1,
recipient=request.user)
notification_list.update(unseen=0)
msg_note = _('All notifications are marked as read.')
if request.method == 'POST':
if request.POST['form-type'] == "change-detail":
user_detail_form = UserChangeDetailForm(request.user,
request.POST,
instance=user_detail)
user_detail_extened_form = \
UserChangeDetailExtendForm(request.user, request.POST,
instance=user_detail_extened)
action = 'tabs-1'
if user_detail_form.is_valid() \
and user_detail_extened_form.is_valid():
#DEMO / Disable
user_detail_form.save()
user_detail_extened_form.save()
msg_detail = _('Detail has been changed.')
else:
error_detail = _('Please correct the errors below.')
elif request.POST['form-type'] == "check-number": # check phone no
action = 'tabs-5'
check_phone_no_form = CheckPhoneNumberForm(data=request.POST)
if check_phone_no_form.is_valid():
if not common_contact_authorization(
request.user, request.POST['phone_number']):
error_number = _('This phone number is not authorized.')
else:
msg_number = _('This phone number is authorized.')
else:
error_number = _('Please correct the errors below.')
else: # "change-password"
user_password_form = PasswordChangeForm(user=request.user,
data=request.POST)
action = 'tabs-2'
if user_password_form.is_valid():
#DEMO / Disable
user_password_form.save()
msg_pass = _('Your password has been changed.')
else:
error_pass = _('Please correct the errors below.')
template = 'frontend/registration/user_detail_change.html'
data = {
'module': current_view(request),
'user_detail_form': user_detail_form,
'user_detail_extened_form': user_detail_extened_form,
'user_password_form': user_password_form,
'check_phone_no_form': check_phone_no_form,
'user_notification': user_notification,
'msg_detail': msg_detail,
'msg_pass': msg_pass,
'msg_number': msg_number,
'msg_note': msg_note,
'error_detail': error_detail,
'error_pass': error_pass,
'error_number': error_number,
'notice_count': notice_count(request),
'dialer_set': dialer_set,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'action': action,
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def editview(request, action):
if request.user.is_authenticated():
request_data = None
context = {}
if request.method == 'POST':
request_data = request.POST
if action == 'password':
form = PasswordChangeForm(user=request.user, data=request_data)
context = {
'form': form,
'action': 'Change password',
'edition': True
}
elif action == 'settings':
tz = 'UTC'
if hasattr(request.user, 'sciriususer'):
tz = request.user.sciriususer.timezone
initial = {'timezone': tz}
if request.user.is_superuser:
form = UserSettingsForm(request_data,
instance=request.user,
initial=initial)
else:
form = NormalUserSettingsForm(request_data,
instance=request.user,
initial=initial)
context = {
'form': form,
'action': 'Edit settings for ' + request.user.username,
'edition': True
}
elif action == 'token':
initial = {}
token = Token.objects.filter(user=request.user)
if len(token):
initial['token'] = token[0]
form = TokenForm(request_data, initial=initial)
context = {'form': form, 'action': 'User token', 'edition': True}
else:
context = {'action': 'User settings', 'edition': False}
if request.method == 'POST':
if action == 'token':
current_tokens = Token.objects.filter(user=request.user)
for token in current_tokens:
token.delete()
Token.objects.create(user=request.user)
return redirect('accounts_edit', action='token')
orig_superuser = request.user.is_superuser
orig_staff = request.user.is_staff
if form.is_valid():
context['edition'] = False
context['action'] = 'User settings'
ruser = form.save(commit=False)
if not orig_superuser:
ruser.is_superuser = False
ruser.is_staff = orig_staff
ruser.save()
if action == 'password':
update_session_auth_hash(request, ruser)
if action == 'settings':
try:
sciriususer = ruser.sciriususer
sciriususer.timezone = form.cleaned_data['timezone']
except:
sciriususer = SciriusUser.objects.create(
user=ruser, timezone=form.cleaned_data['timezone'])
sciriususer.save()
return scirius_render(request, 'accounts/edit.html', context)
def user_update(
request,
ID,
):
if request.method == 'POST' and request.is_ajax():
user = User.objects.get(id=ID)
if request.POST['action'] == 'info':
try:
userForm = UserForm(data=request.POST, instance=user)
if not userForm.is_valid():
raise SystemError(u'資訊輸入錯誤')
userForm.save()
except BaseException as e:
status = 'error'
message = u'使用者資訊更新失敗：{0}'.format(unicode(e))
return locals()
status = 'success'
message = u'使用者資訊更新成功'
return locals()
elif request.POST['action'] == 'info_auth':
try:
infoAuthForm = InfoAuthForm(data=request.POST, instance=user)
if not infoAuthForm.is_valid():
raise SystemError(u'資訊輸入錯誤')
user = infoAuthForm.save()
except BaseException as e:
status = 'error'
message = u'使用者資訊更新失敗：{0}'.format(unicode(e))
return locals()
status = 'success'
message = u'使用者資訊更新成功'
return locals()
elif request.POST['action'] == 'password':
try:
form = PasswordChangeForm(user=user, data=request.POST)
if not form.is_valid():
raise SystemError(u'密碼輸入錯誤')
form.save()
except BaseException as e:
status = 'error'
message = u'使用者密碼更新失敗：{0}'.format(unicode(e))
return locals()
status = 'success'
message = u'使用者密碼更新成功'
return locals()
elif request.POST['action'] == 'role':
try:
form = RoleForm(instance=user, data=request.POST)
if not form.is_valid():
raise SystemError(u'角色權限設定失敗')
form.save()
except BaseException as e:
status = 'error'
message = u'角色權限設定失敗：{0}'.format(unicode(e))
return locals()
status = 'success'
message = u'角色權限設定成功'
return locals()
elif request.POST['action'] == 'disability_card':
try:
print user.disability_card_front
with open(user.disability_card_back, 'wb') as f:
image_content = base64.b64decode(request.POST['back'])
f.write(image_content)
with open(user.disability_card_front, 'wb') as f:
image_content = base64.b64decode(request.POST['front'])
f.write(image_content)
except BaseException as e:
status = 'error'
message = u'身障手冊上傳失敗：{0}'.format(unicode(e))
return locals()
status = 'success'
message = u'身障手冊上傳成功'
return locals()
def post(self, request, *args, **kwargs):
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user)
return redirect('home')
def settings(request, username):
changed = False
active = 'basics'
form = UserInfoForm(instance=request.user,
initial=request.user.get_options())
form_pass = PasswordChangeForm(user=request.user)
if request.method == 'POST':
if 'change_pass' in request.POST:
form_pass = PasswordChangeForm(user=request.user,
data=request.POST)
form = UserInfoForm(instance=request.user)
if form_pass.is_valid():
form_pass.save()
changed = True
elif 'save' in request.POST:
form = UserInfoForm(request.POST, instance=request.user)
form_pass = PasswordChangeForm(user=request.user)
for name in request.POST:
if name.find('option') >= 0:
try:
option = request.user.useroptions_set.get(name=name)
option.value = request.POST[name]
option.save()
except ObjectDoesNotExist:
request.user.useroptions_set.create(
name=name, value=request.POST[name])
if name == 'block_user':
#This is for blocked users
user_name = request.POST[name]
try:
user = UserProfile.objects.get(username=user_name)
except UserProfile.DoesNotExist:
continue
request.user.blocked.add(user)
if form.is_valid():
form.save()
#Pop-up right window
if request.POST.get('form_name') == 'privacy':
active = 'privacy'
else:
active = 'basics'
elif 'rem_hidden' in request.POST:
hidden_users = request.POST.getlist('rem_hidden_list')
for user_id in hidden_users:
try:
user = UserProfile.objects.get(id=user_id)
request.user.hidden.remove(user)
except:
continue
#Pop-up right window
if request.POST.get('form_name') == 'privacy':
active = 'privacy'
else:
active = 'basics'
elif 'rem_blocked' in request.POST:
blocked_users = request.POST.getlist('rem_blocked_list')
for user_id in blocked_users:
try:
user = UserProfile.objects.get(id=user_id)
request.user.blocked.remove(user)
except:
continue
#Pop-up right window
if request.POST.get('form_name') == 'privacy':
active = 'privacy'
else:
active = 'basics'
return render_to_response(
'profile/settings.html', {
'form': form,
'form_pass': form_pass,
'changed': changed,
'active': active,
}, RequestContext(request))
def accountSettings(request):
"""View to the user change his own info
"""
# Change only by post
if request.method == 'POST':
# Checking if the user is requesting the user_change_form
if 'user_change' in request.POST:
# loading the password form to a future request
password_form = PasswordChangeForm(
user=request.user,
prefix='password_form'
)
# loading the user_change_form with the data on POST
user_change_form = PubUserChangeForm(
request.POST, instance=request.user)
# if valids the form will be saved and send a success message
if user_change_form .is_valid():
user_changed = user_change_form.save()
messages.success(request, u'Usuário alterado com sucesso!')
else:
messages.warning(request, u'Houve um problema em alterar \
seus dados de usuário')
# Checking if the user is requesting to change his password
elif 'password' in request.POST:
# loading the user_change_form to a future request
user_change_form = PubUserChangeForm(instance=request.user)
# loading the password_form with the data on POST
password_form = PasswordChangeForm(
user=request.user,
data = request.POST,
prefix='password_form'
)
# if password valids form will be saved and send a success
# message
if password_form.is_valid():
user = password_form.save()
messages.success(request, u'Senha atualizada com sucesso!')
else:
messages.warning(request, u'Houve um problema em alterar \
sua senha')
# Checking if the user is requesting to change his establishment
# address
elif 'address_change' in request.POST:
# loading both forms to future requests
password_form = PasswordChangeForm(
user=request.user,
prefix='password_form'
)
user_change_form = PubUserChangeForm(instance=request.user)
# try to get post values passed by jquery
try:
address = request.POST['address']
lat = request.POST['lat']
long = request.POST['long']
# updating user address
request.user.address = address
request.user.lat = lat
request.user.long = long
# saving user new info
request.user.save()
return HttpResponse("1", content_type="text/json")
# messages.success(request, u'Endereço alterado com sucesso!')
except:
return HttpResponse("0", content_type="text/json")
# messages.warning(request, u'Houve um problema em alterar seu \
# endereço, para qualquer dúvida entre em \
# contato conosco')
else:
# loading both forms to future requests
password_form = PasswordChangeForm(
user=request.user,
prefix='password_form'
)
user_change_form = PubUserChangeForm(instance=request.user)
# user is singing the plan
if 'sign_plan' in request.POST:
request.user.payment_status = request.user.AWATING_APPROVAL
messages.success(request, u'Requisição de assinatura enviada \
com sucesso, aguarde a aprovação no seu \
email!')
# user is canceling the plan
elif 'cancel_plan' in request.POST:
request.user.payment_status = request.user.FREE_TRY
messages.success(request, u'Assinatura cancelada com sucesso!')
else:
password_form = PasswordChangeForm(
user=request.user,
prefix='password_form'
)
user_change_form = PubUserChangeForm(instance=request.user)
# return the request values into the template
return render(request, 'account/account_settings.html',
{ 'password_form': password_form,
'user_change_form': user_change_form
}
)
