Produits Entr'ouvert » Authentic 2

    python-django-filters (>= 1),

    python-pil

    python-django-filters (<< 2),

    python-pil

          'pillow',

    A2_ATTRIBUTE_KIND_PROFILE_IMAGE_MAX_SIZE=Setting(default=200, definition='Max width and height for a profile image'),

import io

import hashlib

import os

from django.utils import html

from django.core.files import File

from django.core.files.storage import default_storage

from .forms import widgets, fields

class ProfileImageFile(object):

    def __init__(self, name):

        self.name = name

    @property

    def url(self):

        return default_storage.url(self.name)

def profile_image_serialize(uploadedfile):

    if not uploadedfile:

        return ''

    if hasattr(uploadedfile, 'url'):

        return uploadedfile.name

    h_computation = hashlib.md5()

    for chunk in uploadedfile.chunks():

        h_computation.update(chunk)

    hexdigest = h_computation.hexdigest()

    stored_file = default_storage.save(

        os.path.join('profile-image', hexdigest),

        uploadedfile)

    return stored_file

def profile_image_deserialize(name):

    if name:

        return ProfileImageFile(name)

    return None

def profile_image_html_value(attribute, value):

    if value:

        fragment = u'<a href="%s"><img class="%s" src="%s"/></a>' % (

            value.url, attribute.name, value.url)

        return html.mark_safe(fragment)

    return ''

def profile_attributes_ng_serialize(ctx, value):

    if value and getattr(value, 'url', None):

        request = ctx.get('request')

        if request:

            return request.build_absolute_uri(value.url)

        else:

            return value.url

    return None

    {

        'label': _('profile image'),

        'name': 'profile_image',

        'field_class': fields.ProfileImageField,

        'serialize': profile_image_serialize,

        'deserialize': profile_image_deserialize,

        'rest_framework_field_class': serializers.FileField,

        'rest_framework_field_kwargs': {

            'read_only': True,

            'use_url': True,

        },

        'html_value': profile_image_html_value,

        'attributes_ng_serialize': profile_attributes_ng_serialize,

    },

    return ('user', 'request')

    for av in AttributeValue.objects.with_owner(user).select_related('attribute'):

        serialize = av.attribute.get_kind().get('attributes_ng_serialize', lambda a, b: b)

        value = av.to_python()

        serialized = serialize(ctx, value)

        ctx['django_user_' + str(av.attribute.name)] = serialized

import warnings

import io

from django.forms import CharField, FileField, ValidationError

from django.forms.fields import FILE_INPUT_CONTRADICTION

from django.core.files import File

from authentic2 import app_settings

from authentic2.forms.widgets import (PasswordInput, NewPasswordInput,

                                      CheckPasswordInput, ProfileImageInput)

import PIL.Image

class ProfileImageField(FileField):

    widget = ProfileImageInput

    def __init__(self, *args, **kwargs):

        kwargs.setdefault(

            'help_text',

            _('Image must be JPG or PNG of size less '

              'than {max_size}x{max_size} pixels').format(max_size=self.max_size))

        super(ProfileImageField, self).__init__(*args, **kwargs)

    @property

    def max_size(self):

        return app_settings.A2_ATTRIBUTE_KIND_PROFILE_IMAGE_MAX_SIZE

    def clean(self, data, initial=None):

        if data is FILE_INPUT_CONTRADICTION or data is False or data is None:

            return super(ProfileImageField, self).clean(data, initial=initial)

        # we have a file

        try:

            with warnings.catch_warnings():

                image = PIL.Image.open(io.BytesIO(data.read()))

        except (IOError, PIL.Image.DecompressionBombWarning):

            raise ValidationError(_('The image is not valid'))

        width, height = image.size

        max_size = app_settings.A2_ATTRIBUTE_KIND_PROFILE_IMAGE_MAX_SIZE

        if width > max_size or height > max_size:

            raise ValidationError(_('The image is bigger than {max_size}x{max_size} pixels')

                                  .format(max_size=self.max_size))

        new_data = self.file_from_image(image, data.name)

        return super(ProfileImageField, self).clean(new_data, initial=initial)

    def file_from_image(self, image, name=None):

        output = io.BytesIO()

        if image.mode != 'RGB':

            image = image.convert('RGB')

        image.save(

            output,

            format='JPEG',

            quality=99,

            optimize=1)

        output.seek(0)

        return File(output, name=name)

import django

from django.forms.widgets import DateTimeInput, DateInput, TimeInput, \

        ClearableFileInput

class ProfileImageInput(ClearableFileInput):

    if django.VERSION < (1, 9):

        template_with_initial = (

        '%(initial_text)s: <a href="%(initial_url)s"><img src="%(initial_url)s"/></a> '

        '%(clear_template)s<br />%(input_text)s: %(input)s'

        )

    else:

        template_name = "authentic2/profile_image_input.html"

MEDIA_ROOT = 'media'

MEDIA_URL = '/media/'

  <form enctype="multipart/form-data" method="post">

{% if widget.is_initial %}{{ widget.initial_text }}: <a href="{{ widget.value.url }}"><img src="{{ widget.value.url }}"/></a>{% if not widget.required %}

<input type="checkbox" name="{{ widget.checkbox_name }}" id="{{ widget.checkbox_id }}" />

<label for="{{ widget.checkbox_id }}">{{ widget.clear_checkbox_label }}</label>{% endif %}<br />

{{ widget.input_text }}:{% endif %}

<input type="{{ widget.type }}" name="{{ widget.name }}"{% include "django/forms/widgets/attrs.html" %} />

<form enctype="multipart/form-data" method="post">

from django.views.static import serve as media_serve

    urlpatterns += [

        url(r'^media/(?P<path>.*)$', media_serve, {

        'document_root': settings.MEDIA_ROOT})

    ]

                html_value = attribute.get_kind().get('html_value', lambda a, b: b)

                value = [html_value(attribute, at_value) for at_value in value]

def create_user_info(request, client, user, scope_set, id_token=False):

        'user': user,

        'request': request,

        'service': client,

        '__wanted_attributes': client.get_wanted_attributes(),

    })

        id_token = utils.create_user_info(request,

                                          client,

                                          request.user,

                                          scopes,

                                          id_token=True)

    id_token = utils.create_user_info(

        request,

        client,

        oidc_code.user,

        oidc_code.scope_set(),

        id_token=True)

    user_info = utils.create_user_info(request,

                                       access_token.client,

                                       access_token.user,

@pytest.fixture

def media(settings, tmpdir):

    settings.MEDIA_ROOT = str(tmpdir.mkdir('media'))

from webtest import Upload

def test_profile_image(db, app, admin, mailoutbox, media):

    Attribute.objects.create(name='cityscape_image', label='cityscape', kind='profile_image',

                             asked_on_registration=True, required=False,

                             user_visible=True, user_editable=True)

    def john():

        return User.objects.get(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)

    # verify empty file is refused

    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')

    # verify 201x201 image is refused

    form = response.form

    form.set('cityscape_image', Upload('tests/201x201.jpg'))

    form.set('password1', '12345abcdA')

    form.set('password2', '12345abcdA')

    response = form.submit()

    assert response.pyquery.find('.form-field-error #id_cityscape_image')

    # verify 200x200 image is accepted

    form = response.form

    form.set('cityscape_image', Upload('tests/200x200.jpg'))

    form.set('password1', '12345abcdA')

    form.set('password2', '12345abcdA')

    response = form.submit()

    assert john().attributes.cityscape_image

    # verify API serves absolute URL for profile images

    app.authorization = ('Basic', (admin.username, admin.username))

    response = app.get('/api/users/%s/' % john().uuid)

    assert response.json['cityscape_image'] == 'http://testserver/media/%s' % john().attributes.cityscape_image.name

    app.authorization = None

    # verify we can clear the 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-clear', True)

    response = form.submit()

    assert john().attributes.cityscape_image == None

    # verify API serves absolute URL for profile images

    app.authorization = ('Basic', (admin.username, admin.username))

    response = app.get('/api/users/%s/' % john().uuid)

    assert response.json['cityscape_image'] is None

from django.core.files import File

from authentic2.models import Attribute

def oidc_client(request, superuser, app, simple_user, media):

    Attribute.objects.create(

        name='cityscape_image',

        label='cityscape',

        kind='profile_image',

        asked_on_registration=True,

        required=False,

        user_visible=True,

        user_editable=True)

    OIDCClaim.objects.create(client=oidc_client,

                             name='cityscape_image',

                             value='django_user_cityscape_image',

                             scopes='profile')

    assert response.json.get('cityscape_image') is None

    simple_user.attributes.cityscape_image = File(open('tests/200x200.jpg'))

    response = app.get(user_info_url, headers=bearer_authentication_headers(access_token))

    assert response.json['cityscape_image'].startswith('http://testserver/media/profile-image/')

import re

from django.core.files import File

        self.avatar_attribute = Attribute.objects.create(

            kind='profile_image',

            name='avatar',

            label='Avatar')

        self.avatar_attribute.set_value(self.user, File(open('tests/200x200.jpg')))

        self.liberty_provider.attributes.create(

            name_format='basic',

            name='avatar',

            friendly_name='Avatar',

            attribute_name='django_user_avatar')

                ("/saml:Assertion/saml:AttributeStatement/saml:Attribute[@Name='avatar']/"

                    "@NameFormat", lasso.SAML2_ATTRIBUTE_NAME_FORMAT_BASIC),

                ("/saml:Assertion/saml:AttributeStatement/saml:Attribute[@Name='avatar']/"

                    "@FriendlyName", 'Avatar'),

                ("/saml:Assertion/saml:AttributeStatement/saml:Attribute[@Name='avatar']/"

                    "saml:AttributeValue", re.compile('^http://testserver/media/profile-image/.*$')),

                elif hasattr(content, 'pattern'):

                    for value in values:

                        self.assertRegexpMatches(

                            value, content,

                            msg='xpath %s does not match regexp %s' % (xpath, content.pattern))