def user_settings(request):
if request.method == 'POST':
form = SettingsForm(request.POST, request.FILES)
if form.is_valid():
im = Image.open(request.FILES['profile_pic'])
im = ImageOps.fit(im, (120, 120), Image.ANTIALIAS)
if not os.path.exists(os.path.join(settings.MEDIA_ROOT,
"profile")):
os.makedirs(os.path.join(settings.MEDIA_ROOT, "profile"))
im.save(
os.path.join(settings.MEDIA_ROOT,
"profile/{}.png".format(request.user.netid)))
request.user.photo = "png"
request.user.save()
messages.success(request, 'Votre profil a été mis à jour.')
return render(request, "users/settings.html",
{'form': SettingsForm()})
else:
form = SettingsForm()
return render(request, 'users/settings.html', {
'form': form,
'stream': actor_stream(request.user),
})
def edit_settings(request):
"""Edit user settings"""
if request.method == 'POST':
form = SettingsForm(request.POST)
if form.is_valid():
form.save_for_user(request.user)
messages.add_message(request, messages.INFO,
_(u'Your settings have been saved.'))
return HttpResponseRedirect(reverse('users.edit_settings'))
# Invalid form
return jingo.render(request, 'users/edit_settings.html',
{'form': form})
# Pass the current user's settings as the initial values.
values = request.user.settings.values()
initial = dict()
for v in values:
try:
# Uses ast.literal_eval to convert 'False' => False etc.
# TODO: Make more resilient.
initial[v['name']] = literal_eval(v['value'])
except (SyntaxError, ValueError):
# Attempted to convert the string value to a Python value
# but failed so leave it a string.
initial[v['name']] = v['value']
form = SettingsForm(initial=initial)
return jingo.render(request, 'users/edit_settings.html', {'form': form})
def settings(request):
user = request.user
if request.method == 'GET':
form = SettingsForm(instance=user)
return render(request,
'users/settings.html',
context={
'form': form,
'showed_user': user,
})
elif request.method == 'POST':
user = request.user
form = SettingsForm(request.POST, request.FILES, instance=user)
form.set_user(user)
if form.is_valid():
form.image = request.FILES.get('image')
form.save()
return redirect(f'/accounts/account/{user.username}')
else:
return render(request,
'users/settings.html',
context={
'form': form,
'showed_user': user,
})
def test_non_existant_setting(self):
user = User.objects.all()[0]
form = SettingsForm()
bad_setting = 'doesnt_exist'
assert bad_setting not in form.fields.keys()
with self.assertRaises(KeyError):
Setting.get_for_user(user, bad_setting)
def test_clean_with_valid_username_email(self):
form_data = {'username': '******', 'email': '*****@*****.**'}
form = SettingsForm(data=form_data,
user=self.user,
request=self.request)
form.is_valid()
form.clean()
self.assertEqual(form.errors, {})
def test_save_email(self):
form_data = {'email': '*****@*****.**'}
form = SettingsForm(data=form_data,
user=self.user,
request=self.request)
form.is_valid()
user = form.save()
self.assertEqual(user.email, '*****@*****.**')
def test_clean_with_existing_email(self):
User.objects.create_user(email='*****@*****.**')
form_data = {'email': '*****@*****.**'}
form = SettingsForm(data=form_data,
user=self.user,
request=self.request)
form.is_valid()
form.clean()
self.assertNotEqual(form.errors, {})
def test_save_username(self):
form_data = {'username': '******'}
form = SettingsForm(data=form_data,
user=self.user,
request=self.request)
form.is_valid()
user = form.save()
self.assertEqual(user.username, 'newusername')
def test_save_all_empty_string(self):
form_data = {'username': '', 'email': '', 'password': ''}
form = SettingsForm(data=form_data,
user=self.user,
request=self.request)
form.is_valid()
user = form.save()
self.assertEqual(user.email, self.user.email)
self.assertTrue(user.check_password('password'))
def home(request, note=""):
""" The settings page for users
If you post a SettingsForm to this, it will be saved. In all cases, it renders index.html to provide the user some
account managment things.
This view may also take a note, in which case the note will be displayed at the top of the page and the request
will run as if it were a GET.
"""
if request.method == "POST" and not note:
form = SettingsForm(request.POST, instance=request.user.settings)
if form.is_valid():
form.save()
note = "Settings Updated Successfully"
else:
form = SettingsForm(instance=request.user.settings)
ctx = _make_context(request, "settings_form", form)
ctx["note"] = note
return TemplateResponse(request, "users/index.html", ctx)
def get_for_user(cls, user, name):
from users.forms import SettingsForm
form = SettingsForm()
if name not in form.fields.keys():
raise KeyError(("'{name}' is not a field in "
"user.forms.SettingsFrom()").format(name=name))
try:
setting = Setting.uncached.get(user=user, name=name)
except Setting.DoesNotExist:
value = form.fields[name].initial or ''
setting = Setting.objects.create(user=user, name=name, value=value)
# Cast to the field's Python type.
return form.fields[name].to_python(setting.value)
def _make_context(request, form_name, form_value):
ctx = {}
# TODO: Is creating forms expensive
ctx["area"] = "user"
ctx["importForm"] = ImportForm()
ctx["pass_form"] = PasswordChangeForm(request.user)
ctx["email_form"] = EmailForm(instance=request.user)
ctx["settings_form"] = SettingsForm(instance=request.user.settings)
ctx["theme_form"] = ThemeForm(instance=request.user.settings)
ctx[form_name] = form_value
return ctx
def get_context_data(self, **kwargs):
# Call the base implementation first to get a context
context = super(UsersettingsView, self).get_context_data(**kwargs)
# Add in a QuerySet of all the books
if self.request.method != "POST":
context['settingsform'] = SettingsForm(instance=self.request.user)
context['avatarform'] = AvatarForm(instance=self.request.user)
if "settingsform" in context:
context['settingsform'].fields[
"main_department"].queryset = self.request.user.departments.all(
)
# adds "Settings" to breadcrumbs
context["breadcrumbs"] = [(reverse("userprofile",
kwargs={"pk": self.request.user.pk
}), self.request.user),
("", _("Settings"))]
return context
def post(self, request):
context = self.get_context_data()
context["settingsform"] = SettingsForm(instance=request.user)
context["avatarform"] = AvatarForm(instance=request.user)
context['settingsform'].fields[
"main_department"].queryset = self.request.user.departments.all()
# handle language settings and use saved settings of user as default
if "language" in request.POST:
request.user.language = request.POST["language"]
request.user.save()
translation.activate(request.POST["language"])
request.session[
translation.LANGUAGE_SESSION_KEY] = request.POST["language"]
return HttpResponseRedirect(reverse("usersettings"))
# handle pagelength/ timezone/ theme settings and use saved settings of user as default
elif "pagelength" in request.POST or "timezone" in request.POST or "theme" in request.POST:
form = SettingsForm(request.POST)
if form.is_valid():
changed_data = False
# change of pagelength settings
if request.user.pagelength != form.cleaned_data["pagelength"]:
request.user.pagelength = form.cleaned_data["pagelength"]
changed_data = True
# change of timezone settings
if request.user.timezone != form.cleaned_data["timezone"]:
request.user.timezone = form.cleaned_data["timezone"]
changed_data = True
# change of main department settings
if request.user.main_department != form.cleaned_data[
"main_department"]:
request.user.main_department = form.cleaned_data[
"main_department"]
changed_data = True
# change of theme settings
if request.user.theme != form.cleaned_data["theme"]:
request.user.theme = form.cleaned_data["theme"]
changed_data = True
# save changes
if changed_data:
request.user.save()
# save success message
messages.success(self.request,
_('Settings were successfully updated'))
context["settingsform"] = form
# handle given avatar
elif "avatar" in request.FILES or "avatar" in request.POST:
if request.user.avatar:
tempavatar = request.user.avatar
else:
tempavatar = None
form = AvatarForm(request.POST,
request.FILES,
instance=request.user)
if form.is_valid():
if form.cleaned_data[
"avatar_clear"] and request.user.avatar is not None:
request.user.avatar.delete()
request.user.avatar = None
request.user.save()
if tempavatar is not None:
tempavatar.storage.delete(tempavatar)
form.save()
context["avatarform"] = form
return render(request, self.template_name, context)
def test_non_existant_setting(self):
form = SettingsForm()
bad_setting = 'doesnt_exist'
assert bad_setting not in form.fields.keys()
with self.assertRaises(KeyError):
Setting.get_for_user(self.u, bad_setting)
