0001-support-avatar-picture-in-user-profile-26022.patch

Paul Marillonnet, 01 octobre 2018 17:29

Voir les différences: en ligne côte à côte

Subject: [PATCH] support avatar picture in user profile (#26022)

 debian-wheezy/control                         |   3 +-
 debian/control                                |   3 +-
 setup.py                                      |   2 +
 src/authentic2/app_settings.py                |   3 +
 src/authentic2/attribute_kinds.py             |  18 ++
 src/authentic2/forms/widgets.py               |  25 ++-
 src/authentic2/models.py                      |  19 +-
 src/authentic2/settings.py                    |   3 +
 .../templates/authentic2/accounts.html        |  20 +-
 .../templates/authentic2/accounts_edit.html   |   3 +-
 .../templates/authentic2/accounts_image.html  |   6 +
 .../registration/registration_form.html       |   3 +-
 src/authentic2/templatetags/__init__.py       |   0
 src/authentic2/templatetags/authentic2.py     |  22 +++
 src/authentic2/urls.py                        |   5 +
 src/authentic2/utils.py                       |  65 +++++++
 tests/conftest.py                             |  19 ++
 tests/test_attribute_kinds.py                 | 181 ++++++++++++++++++
 tests/test_manager.py                         |  23 +--
 tests/test_profile.py                         |  16 +-
 "tests/une deuxi\303\250me image.png"         | Bin 0 -> 506 bytes
 "tests/une premi\303\250re image.png"         | Bin 0 -> 508 bytes
 tox.ini                                       |   2 +
 23 files changed, 410 insertions(+), 31 deletions(-)
 create mode 100644 src/authentic2/templates/authentic2/accounts_image.html
 create mode 100644 src/authentic2/templatetags/__init__.py
 create mode 100644 src/authentic2/templatetags/authentic2.py
 create mode 100644 "tests/une deuxi\303\250me image.png"
 create mode 100644 "tests/une premi\303\250re image.png"

         python-markdown (>= 2.1),
         python-ldap (>= 2.4),
         python-six (>= 1.0),
         python-django-filters (>= 1)
         python-django-filters (>= 1),
         python-sorl-thumbnail
     Provides: ${python:Provides}
     Recommends: python-ldap
     Suggests: python-raven

         python-jwcrypto (>= 0.3.1),
         python-cryptography (>= 1.3.4),
         python-django-filters (>= 1),
         python-django-filters (<< 2)
         python-django-filters (<< 2),
         python-sorl-thumbnail
     Provides: ${python:Provides}
     Recommends: python-ldap
     Suggests: python-raven

               'XStatic-jQuery',
               'XStatic-jquery-ui<1.12',
               'xstatic-select2',
               'sorl-thumbnail',
               'pillow',
           ],
           zip_safe=False,
           classifiers=[

                 'next try after a login failure'),
         A2_VERIFY_SSL=Setting(default=True, definition='Verify SSL certificate in HTTP requests'),
         A2_ATTRIBUTE_KIND_TITLE_CHOICES=Setting(default=(), definition='Choices for the title attribute kind'),
         A2_ATTRIBUTE_KIND_IMAGE_DIMENSIONS=Setting(default="150x150", definition='Width x Height image dimensions in account management page.'),
         A2_ATTRIBUTE_KIND_IMAGE_CROPPING=Setting(default="center", definition='Image cropping in account management page.'),
         A2_ATTRIBUTE_KIND_IMAGE_QUALITY=Setting(default=99, definition='Image quality in account management page.'),
         A2_CORS_WHITELIST=Setting(default=(), definition='List of origin URL to whitelist, must be scheme://netloc[:port]'),
         A2_EMAIL_CHANGE_TOKEN_LIFETIME=Setting(default=7200, definition='Lifetime in seconds of the '
                                                'token sent to verify email adresses'),

     from .plugins import collect_from_plugins
     from . import app_settings
     from .forms import widgets
     from .utils import image_serialize, image_deserialize
     capfirst = allow_lazy(capfirst, unicode)
-...
     def get_title_choices():
         return app_settings.A2_ATTRIBUTE_KIND_TITLE_CHOICES or DEFAULT_TITLE_CHOICES
     validate_phone_number = RegexValidator('^\+?\d{,20}$', message=_('Phone number can start with a + '
                                                                      'an must contain only digits.'))
-...
             'field_class': PhoneNumberField,
             'rest_framework_field_class': PhoneNumberDRFField,
         },
+        {
             'label': _('image'),
             'name': 'image',
             'field_class': forms.ImageField,
             'kwargs': {
                 'widget': widgets.AttributeImageInput,
             },
             'serialize': image_serialize,
             'serialize_eval_kwargs': {
                 'attr_label': 'self.label',
             },
             'deserialize': image_deserialize,
             'rest_framework_field_kwargs': {
                 'read_only': True,
                 },
         },
+    ]

     import re
     import uuid
     from django.forms.widgets import DateTimeInput, DateInput, TimeInput
     from django.forms.widgets import DateTimeInput, DateInput, TimeInput, \
             ClearableFileInput
     from django.forms.widgets import PasswordInput as BasePasswordInput
     from django.utils.formats import get_language, get_format
     from django.utils.safestring import mark_safe
-...
                         json.dumps(_id),
+                    )
             return output
     class AttributeImageInput(ClearableFileInput):
         import django
         if django.VERSION < (1, 9):
             template_with_initial = (
                 '%(initial_text)s: <br /> <img src="%(initial)s"/> <br />'
                 '%(clear_template)s<br />%(input_text)s: %(input)s'
+            )
         else:
             template_name = "authentic2/accounts_image.html"
         def is_initial(self, value):
             return bool(value)
         def get_template_substitution_values(self, value):
             subs_values = dict()
             subs_values.update({
                 'initial': value,
             })
             return subs_values

     import logging
     import time
     import urlparse
     import uuid
-...
                     return kind['default']
         def set_value(self, owner, value, verified=False):
             logger = logging.getLogger(__name__)
             serialize = self.get_kind()['serialize']
             # setting to None is to delete
             if value is None:
-...
                         av.verified = verified
                         av.save()
             else:
                 content = serialize(value)
                 kwargs = dict()
                 for key, flat_value in self.get_kind().get('serialize_eval_kwargs', {}).items():
                     try:
                         evalue = eval(flat_value)
                     except NameError:
                         logger.error("Couldn't evaluate {} for attribute <{}: {}>".format(
                                 flat_value,
                                 self.get_kind()['kind'],
                                 self.label))
                         continue
                     kwargs.update({key: evalue})
                 if kwargs:
                     content = serialize(value, **kwargs)
                 else:
                     content = serialize(value)
                 av, created = AttributeValue.objects.get_or_create(
                         content_type=ContentType.objects.get_for_model(owner),
                         object_id=owner.pk,

     DEBUG = False
     DEBUG_DB = False
     MEDIA = 'media'
     MEDIA_ROOT = 'media'
     MEDIA_URL = '/media/'
     # See https://docs.djangoproject.com/en/dev/ref/settings/#allowed-hosts
     ALLOWED_HOSTS = []
-...
         'xstatic.pkg.jquery',
         'xstatic.pkg.jquery_ui',
         'xstatic.pkg.select2',
         'sorl.thumbnail',
+    )
     INSTALLED_APPS = tuple(plugins.register_plugins_installed_apps(INSTALLED_APPS))

     {% extends "authentic2/base-page.html" %}
     {% load i18n %}
     {% load authentic2 %}
     {% block page-title %}
       {{ block.super }} - {{ view.title }}
-...
               {% for attribute in attributes %}
                 <dt>{{ attribute.attribute.label|capfirst }}&nbsp;:</dt>
                 <dd>
                   {% if attribute.values|length == 1 %}
                     {{ attribute.values.0 }}
                   {% if attribute.attribute.kind == 'image' %}
                       {% thumbnail attribute.values.0 as thumb_im %}
                       <img class="{{ attribute.attribute.name }}" src="{{ thumb_im.url }}">
                   {% else %}
                     <ul>
                       {% for value in attribute.values %}
                         <li>{{ value }}</li>
                       {% endfor %}
                     </ul>
                     {% if attribute.values|length == 1 %}
                       {{ attribute.values.0 }}
                     {% else %}
                       <ul>
                         {% for value in attribute.values %}
                           <li>{{ value }}</li>
                         {% endfor %}
                       </ul>
                     {% endif %}
                   {% endif %}
                 </dd>
               {% endfor %}

     {% endblock %}
     {% block content %}
       <form method="post">
       <form enctype="multipart/form-data" method="post">
         {% csrf_token %}
         {{ form.as_p }}
         {% if form.instance and form.instance.id %}

src/authentic2/templates/authentic2/accounts_image.html
	1	{% if widget.is_initial %}{{ widget.initial_text }}: <img src="{{ widget.value }}"/><br />
	2	{% if not widget.required %}
	3	<input type="checkbox" name="{{ widget.checkbox_name }}" id="{{ widget.checkbox_id }}" />
	4	<label for="{{ widget.checkbox_id }}">{{ widget.clear_checkbox_label }}</label>{% endif %}
	5	{{ widget.input_text }}:{% endif %}
	6	<input type="{{ widget.type }}" name="{{ widget.name }}"{% include "django/forms/widgets/attrs.html" %} />

     <h2>{{ view.title }}</h2>
     <form method="post">
     <form enctype="multipart/form-data" method="post">
       {% csrf_token %}
       {{ form.as_p }}
       <button class="submit-button">{% trans 'Submit' %}</button>

     import logging
     from django import template
     from sorl.thumbnail import get_thumbnail
     from .. import app_settings
     register = template.Library()
     @register.assignment_tag(takes_context=True)
     def thumbnail(context, img_value):
         logger = logging.getLogger(__name__)
         try:
             img_url = context['request'].build_absolute_uri(img_value)
             dimensions = app_settings.A2_ATTRIBUTE_KIND_IMAGE_DIMENSIONS
             crop = app_settings.A2_ATTRIBUTE_KIND_IMAGE_CROPPING
             quality =  app_settings.A2_ATTRIBUTE_KIND_IMAGE_QUALITY
             return get_thumbnail(img_url, dimensions, crop=crop, quality=quality)
         except:
             logger.error("Couldn't generate thumbnail for image {}".format(
                     img_value))

     from django.conf import settings
     from django.contrib import admin
     from django.contrib.staticfiles.views import serve
     from django.views.static import serve as media_serve
     from . import app_settings, plugins, views
-...
         urlpatterns += [
             url(r'^static/(?P<path>.*)$', serve)
+        ]
         urlpatterns += [
             url(r'^media/(?P<path>.*)$', media_serve, {
             'document_root': settings.MEDIA_ROOT})
+        ]
     if settings.DEBUG and 'debug_toolbar' in settings.INSTALLED_APPS:
         import debug_toolbar

     import uuid
     import datetime
     import copy
     import os
     from functools import wraps
     from itertools import islice, chain, count
-...
     from django.template.loader import render_to_string, TemplateDoesNotExist
     from django.core.mail import send_mail
     from django.core import signing
     from django.core.files.storage import default_storage
     from django.core.urlresolvers import reverse, NoReverseMatch
     from django.utils.formats import localize
     from django.contrib import messages
-...
             if ou_value is not None:
                 return ou_value
         return default
     def _store_image(in_memory_image):
         from hashlib import sha1
         h = sha1(in_memory_image.read()).hexdigest()
         extension = in_memory_image.image.format
         img_tmp_path = u'images/%s/%s.%s' % (h[:3], h[3:], extension)
         img_media_path = default_storage.save(img_tmp_path, in_memory_image)
         return img_media_path
     def _delete_images_from_user(attr_label):
         from .models import Attribute, AttributeValue
         from .middleware import StoreRequestMiddleware
         logger = logging.getLogger(__name__)
         User = get_user_model()
         request = StoreRequestMiddleware.get_request()
         try:
             user = request.user
         except :
             logger.error("Couldn't retrieve user for request {}.".format(request))
             return
         try:
             attr = Attribute.objects.get(label=attr_label)
             all_values =  AttributeValue.objects.with_owner(user)
             values = all_values.filter(attribute=attr)
         except:
             logger.error("Couldn't retrieve values for Attribute {}.".format(attr_label))
             return
         for value in values:
             if value.content:
                 default_storage.delete(value.content)
             value.delete()
     def image_serialize(image, attr_label):
         from urllib import unquote
         img_media_path = ''
         if isinstance(image, basestring):
             img_url = unquote(image).decode('utf8')
             img_media_path = img_url.split(default_storage.base_url)[-1]
         else:
             # Discard previous user images
             _delete_images_from_user(attr_label)
             if image:
                 img_media_path = _store_image(image)
         return img_media_path
     def image_deserialize(img_media_path):
         from authentic2.middleware import StoreRequestMiddleware
         if img_media_path:
             request = StoreRequestMiddleware().get_request()
             img_uri = os.path.join(settings.MEDIA_URL, img_media_path)
             return request.build_absolute_uri(img_uri)

         activate('fr')
         yield
         deactivate()
     @pytest.fixture(autouse=True)
     def authentic_settings(settings, tmpdir):
         settings.MEDIA_ROOT = str(tmpdir)
     @pytest.fixture
     def monkeyrequest(monkeypatch):
         from django.test import RequestFactory
         def fake_absolute_uri(uri=None):
                 return u'http://testserver/{}'.format(uri or u'')
         request = RequestFactory()
         request.build_absolute_uri = lambda x: None
         monkeypatch.setattr(request, 'build_absolute_uri', fake_absolute_uri)
         return request

         app.post_json('/api/users/', params=payload)
         assert qs.get().attributes.phone_number == ''
         qs.delete()
     def test_image(db, app, admin, mailoutbox, monkeypatch, monkeyrequest):
         from webtest import Upload
         from authentic2.middleware import StoreRequestMiddleware
         from hashlib import sha1
         Attribute.objects.create(name='cityscape_image', label='cityscape', kind='image',
                                  asked_on_registration=True, required=False,
                                  user_visible=True, user_editable=True)
         qs = User.objects.filter(first_name='John')
         response = app.get('/accounts/register/')
         form = response.form
         form.set('email', 'john.doe@example.com')
         response = form.submit().follow()
         assert 'john.doe@example.com' in response
         url = get_link_from_mail(mailoutbox[0])
         response = app.get(url)
         form = response.form
         form.set('first_name', 'John')
         form.set('last_name', 'Doe')
         form.set('cityscape_image', Upload('/dev/null'))
         form.set('password1', '12345abcdA')
         form.set('password2', '12345abcdA')
         response = form.submit()
         assert response.pyquery.find('.form-field-error #id_cityscape_image')
         form = response.form
         form.set('cityscape_image', Upload('tests/une première image.png'))
         form.set('password1', '12345abcdA')
         form.set('password2', '12345abcdA')
         response = form.submit()
         with open('tests/une première image.png') as f:
             john = qs.get()
             xdigest = sha1(f.read()).hexdigest()
             monkeypatch.setattr(StoreRequestMiddleware, 'get_request', lambda cls: monkeyrequest)
             assert xdigest[:3] in john.attributes.cityscape_image
             assert xdigest[3:] in john.attributes.cityscape_image
             monkeypatch.undo()
         app.authorization = ('Basic', (admin.username, admin.username))
         resp = app.get('/api/users/?first_name=John&last_name=Doe')
         with open('tests/une première image.png') as f:
             xdigest = sha1(f.read()).hexdigest()
             assert xdigest[:3] in resp.json_body['results'][0]['cityscape_image']
             assert xdigest[3:] in resp.json_body['results'][0]['cityscape_image']
         response = app.get('/accounts/edit/')
         form = response.form
         form.set('edit-profile-first_name', 'John')
         form.set('edit-profile-last_name', 'Doe')
         form.set('edit-profile-cityscape_image', None)
         response = form.submit()
         monkeypatch.setattr(StoreRequestMiddleware, 'get_request', lambda cls: monkeyrequest)
         assert qs.get().attributes.cityscape_image == None
         monkeypatch.undo()
         qs.delete()
     def test_images_delete_on_form_field_clearance(db, app, admin, mailoutbox):
         from django.core.files.storage import default_storage
         from webtest import Upload
         from hashlib import sha1
         Attribute.objects.create(
                 name='cityscape_image', label='cityscape', kind='image',
                 asked_on_registration=False, required=False,
                 user_visible=True, user_editable=True)
         Attribute.objects.create(
                 name='garden_image', label='garden', kind='image',
                 asked_on_registration=False, required=False,
                 user_visible=True, user_editable=True)
         qs = User.objects.filter(first_name='John')
         response = app.get('/accounts/register/')
         form = response.form
         form.set('email', 'john.doe@example.com')
         response = form.submit().follow()
         assert 'john.doe@example.com' in response
         url = get_link_from_mail(mailoutbox[0])
         response = app.get(url)
         form = response.form
         form.set('first_name', 'John')
         form.set('last_name', 'Doe')
         form.set('password1', '12345abcdA')
         form.set('password2', '12345abcdA')
         response = form.submit()
         john = qs.get()
         assert john
         f = open('tests/une première image.png')
         h = sha1(f.read()).hexdigest()
         img_path1 = 'images/%s/%s.PNG' % (h[:3], h[3:])
         f.close()
         f =  open('tests/une deuxième image.png')
         h = sha1(f.read()).hexdigest()
         img_path2 = 'images/%s/%s.PNG' % (h[:3], h[3:])
         f.close()
         assert not default_storage.exists(img_path1)
         assert not default_storage.exists(img_path2)
         response = app.get('/accounts/edit/')
         form = response.form
         form.set('edit-profile-cityscape_image', Upload('tests/une première image.png'))
         response = form.submit()
         assert default_storage.exists(img_path1)
         assert not default_storage.exists(img_path2)
         response = app.get('/accounts/edit/')
         form = response.form
         form.set('edit-profile-garden_image', Upload('tests/une deuxième image.png'))
         response = form.submit()
         assert default_storage.exists(img_path1)
         assert default_storage.exists(img_path2)
         response = app.get('/accounts/edit/')
         form = response.form
         form.set('edit-profile-cityscape_image-clear', True)
         response = form.submit()
         assert not default_storage.exists(img_path1)
         assert default_storage.exists(img_path2)
         response = app.get('/accounts/edit/')
         form = response.form
         form.set('edit-profile-garden_image-clear', True)
         response = form.submit()
         assert not default_storage.exists(img_path1)
         assert not default_storage.exists(img_path2)
     def test_images_account_registration(db, app, admin, mailoutbox, monkeypatch, monkeyrequest):
         from webtest import Upload
         from authentic2.middleware import StoreRequestMiddleware
         from django.test import RequestFactory
         Attribute.objects.create(name='cityscape_image', label='cityscape', kind='image',
                                  asked_on_registration=True)
         Attribute.objects.create(name='garden_image', label='garden', kind='image',
                                  asked_on_registration=True)
         qs = User.objects.filter(first_name='John')
         response = app.get('/accounts/register/')
         form = response.form
         form.set('email', 'john.doe@example.com')
         response = form.submit().follow()
         assert 'john.doe@example.com' in response
         url = get_link_from_mail(mailoutbox[0])
         response = app.get(url)
         form = response.form
         assert form.get('cityscape_image')
         assert form.get('garden_image')
         form.set('first_name', 'John')
         form.set('last_name', 'Doe')
         form.set('cityscape_image', Upload('tests/une première image.png'))
         form.set('garden_image', Upload('tests/une deuxième image.png'))
         form.set('password1', '12345abcdA')
         form.set('password2', '12345abcdA')
         response = form.submit()
         john = qs.get()
         monkeypatch.setattr(StoreRequestMiddleware, 'get_request', lambda cls: monkeyrequest)
         assert john.attributes.cityscape_image
         assert john.attributes.garden_image
         monkeypatch.undo()
         john.delete()

         resp = login(app, superuser,
                      reverse('a2-manager-user-detail', kwargs={'pk': simple_user.pk}))
         assert len(mail.outbox) == 0
         resp = resp.form.submit('password_reset')
         assert 'A mail was sent to' in resp
         assert len(mail.outbox) == 1
         url = get_link_from_mail(mail.outbox[0])
         relative_url = url.split('testserver')[1]
         resp = app.get('/logout/').maybe_follow()
         resp = app.get(relative_url, status=200)
         resp.form.set('new_password1', '1234==aA')
         resp.form.set('new_password2', '1234==aA')
         resp = resp.form.submit().follow()
         assert str(app.session['_auth_user_id']) == str(simple_user.pk)
         if resp.form.enctype == u'application/x-www-form-urlencoded':
             resp = resp.form.submit('password_reset')
             assert 'A mail was sent to' in resp
             assert len(mail.outbox) == 1
             url = get_link_from_mail(mail.outbox[0])
             relative_url = url.split('testserver')[1]
             resp = app.get('/logout/').maybe_follow()
             resp = app.get(relative_url, status=200)
             resp.form.set('new_password1', '1234==aA')
             resp.form.set('new_password2', '1234==aA')
             resp = resp.form.submit().follow()
             assert str(app.session['_auth_user_id']) == str(simple_user.pk)
     def test_manager_user_detail_by_uuid(app, superuser, simple_user):

         assert attribute.get_value(simple_user) == '0123456789'
         resp = app.get(url, status=200)
         resp.form.set('edit-profile-phone', '9876543210')
         resp = resp.form.submit('cancel').follow()
         assert attribute.get_value(simple_user) == '0123456789'
         if resp.form.enctype == u'application/x-www-form-urlencoded':
             resp.form.set('edit-profile-phone', '9876543210')
             resp = resp.form.submit('cancel').follow()
             assert attribute.get_value(simple_user) == '0123456789'
         attribute.set_value(simple_user, '0123456789', verified=True)
         resp = app.get(url, status=200)
-...
         assert attribute.get_value(simple_user) == '0123456789'
         resp = app.get(url + '?next=%s' % external_redirect_next_url, status=200)
         resp.form.set('edit-profile-phone', '1234')
         resp = resp.form.submit('cancel')
         assert_external_redirect(resp, reverse('account_management'))
         assert attribute.get_value(simple_user) == '0123456789'
         if resp.form.enctype == u'application/x-www-form-urlencoded':
             resp.form.set('edit-profile-phone', '1234')
             resp = resp.form.submit('cancel')
             assert_external_redirect(resp, reverse('account_management'))
             assert attribute.get_value(simple_user) == '0123456789'
     def test_account_edit_scopes(app, simple_user):

       httmock
       pytz
       pytest-freezegun
       pillow
       sorl-thumbnail
     commands =
       ./getlasso.sh
       authentic: py.test {env:FAST:} {env:REUSEDB:} {env:COVERAGE:} {posargs:tests/ --random}
+    -

Projet

Général

Profil

Produits Entr'ouvert » Authentic 2

0001-support-avatar-picture-in-user-profile-26022.patch