Produits Entr'ouvert » Authentic 2

    python-django-filters (>= 1),

    python-sorl-thumbnail

    python-django-filters (<< 2),

    python-sorl-thumbnail

          'sorl-thumbnail',

          'pillow',

    A2_ATTRIBUTE_KIND_IMAGE_DIMENSIONS=Setting(default="", definition='Width x Height image dimensions in account management page.'),

    A2_ATTRIBUTE_KIND_IMAGE_CROPPING=Setting(default="", definition='Image cropping in account management page.'),

    A2_ATTRIBUTE_KIND_IMAGE_QUALITY=Setting(default=None, definition='Image quality in account management page.'),

from .utils import image_serialize, image_deserialize

DEFAULT_IMAGE_DIMENSIONS = "150x150"

DEFAULT_IMAGE_CROPPING = "center"

DEFAULT_IMAGE_QUALITY = 99

def get_image_thumbnail_parameters():

    return (app_settings.A2_ATTRIBUTE_KIND_IMAGE_DIMENSIONS or DEFAULT_IMAGE_DIMENSIONS,

        app_settings.A2_ATTRIBUTE_KIND_IMAGE_CROPPING or DEFAULT_IMAGE_CROPPING,

        app_settings.A2_ATTRIBUTE_KIND_IMAGE_QUALITY or DEFAULT_IMAGE_QUALITY)

    {

        'label': _('image'),

        'name': 'image',

        'field_class': forms.ImageField,

        'kwargs': {

            'widget': widgets.AttributeImageInput,

        },

        'serialize': image_serialize,

        'serialize_eval_kwargs': {

            'owner_uuid': 'owner.uuid',

            'owner_pk': 'owner.pk',

            'attr_label': 'self.label',

        },

        'deserialize': image_deserialize,

        'rest_framework_field_kwargs': {

            'read_only': True,

            },

    },

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

        ClearableFileInput

class AttributeImageInput(ClearableFileInput):

    template_name = "authentic2/accounts_image.html"

    # Deprecated (django<=1.8 only):

    template_with_initial = (

        '%(initial_text)s: <br /> <img src="%(initial)s"/> <br />'

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

    )

    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

        logger = logging.getLogger(__name__)

            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)

MEDIA_ROOT = 'media'

MEDIA_URL = '/media/'

    'sorl.thumbnail',

{% load authentic2 %}

              {% if attribute.attribute.kind == 'image' %}

                  {% thumbnail attribute.values.0 as thumb_im %}

                  <img class="{{ attribute.attribute.name }}" src="{{ thumb_im.url }}">

                {% if attribute.values|length == 1 %}

                  {{ attribute.values.0 }}

                {% else %}

                  <ul>

                    {% for value in attribute.values %}

                      <li>{{ value }}</li>

                    {% endfor %}

                  </ul>

                {% endif %}

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

{% if widget.is_initial %}{{ widget.initial_text }}: <img src="{{ widget.value }}"/><br />

{% 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 %}

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

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

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

import logging

from django import template

from sorl.thumbnail import get_thumbnail

from ..attribute_kinds import get_image_thumbnail_parameters

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, crop, quality = get_image_thumbnail_parameters()

        return get_thumbnail(img_url, dimensions, crop=crop, quality=quality)

    except:

        logger.error("Couldn't generate thumbnail for image {}".format(

                img_value))

from django.views.static import serve as media_serve

    urlpatterns += [

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

        'document_root': settings.MEDIA_ROOT})

    ]

import os

from django.core.files.storage import default_storage

def _store_image(in_memory_image, owner_uuid, attr_label):

    img_tmp_path = u'{label}/{uuid_short}/{uuid}_{name}'.format(

            label=attr_label,

            uuid_short=owner_uuid[0:4],

            uuid=owner_uuid,

            name=in_memory_image.name)

    img_media_path = default_storage.save(img_tmp_path, in_memory_image)

    return img_media_path

def _delete_images_from_user(owner_pk, attr_label):

    from .models import Attribute, AttributeValue

    logger = logging.getLogger(__name__)

    User = get_user_model()

    try:

        owner = User.objects.get(pk=owner_pk)

    except User.DoesNotExist:

        logger.error("Primary key {} doesn't match with any user.".format(owner_pk))

        return

    try:

        attr = Attribute.objects.get(label=attr_label)

        all_values =  AttributeValue.objects.with_owner(owner)

        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:

            # Direct URI <-> file location correspondence

            local_file = value.content.split(default_storage.base_url)[-1]

            default_storage.delete(local_file)

        value.delete()

def image_serialize(image, owner_uuid, owner_pk, attr_label):

    img_media_path = ''

    if isinstance(image, basestring):

        img_media_path = image

    else:

        # Discard previous user avatars

        _delete_images_from_user(owner_pk, attr_label)

        if image:

            img_media_path = _store_image(image, owner_uuid, attr_label)

    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)

@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):

        return u'http://testserver/{}'.format(uri)

    request = RequestFactory()

    request.build_absolute_uri = lambda: None

    monkeypatch.setattr(request, 'build_absolute_uri', fake_absolute_uri)

    return request

def test_image(db, app, admin, mailoutbox, monkeypatch, monkeyrequest):

    from webtest import Upload

    from authentic2.middleware import StoreRequestMiddleware

    Attribute.objects.create(name='cityscape_image', label='cityscape', 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

    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/cityscape.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.uuid 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')

    assert john.uuid in resp.json_body['results'][0]['cityscape_image']

    qs.delete()

    response = app.get(url)

    form = response.form

    form.set('first_name', 'John')

    form.set('last_name', 'Doe')

    form.set('cityscape_image', None)

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

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

    response = form.submit().follow()

    assert qs.get().attributes.cityscape_image == None

    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

    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

    img_path1 = 'cityscape/{uuid_short}/{uuid}_cityscape.png'.format(

            uuid_short=john.uuid[0:4],

            uuid=john.uuid)

    img_path2 = 'garden/{uuid_short}/{uuid}_garden.png'.format(

            uuid_short=john.uuid[0:4],

            uuid=john.uuid)

    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/cityscape.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/garden.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/cityscape.png'))

    form.set('garden_image', Upload('tests/garden.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()

    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)

    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'

    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'

  pillow

  sorl-thumbnail