Produits Entr'ouvert » Authentic 2

    python-django-filters (>= 1),

    python-sorl-thumbnail

    python-django-filters (<< 2),

    python-sorl-thumbnail

          'sorl-thumbnail',

          'pillow',

    return request.user.to_json(request)

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

from .utils import image_serialize

DEFAULT_IMAGE_DIMENSIONS = "150x150"

DEFAULT_IMAGE_CROPPING = "center"

def get_image_dimensions():

    return app_settings.A2_ATTRIBUTE_KIND_IMAGE_DIMENSIONS or DEFAULT_IMAGE_DIMENSIONS

def get_image_cropping():

    return app_settings.A2_ATTRIBUTE_KIND_IMAGE_CROPPING or DEFAULT_IMAGE_CROPPING

class A2ImageDRFField(serializers.ImageField):

    def to_representation(self, value):

        return self.context['request'].build_absolute_uri(value)

    {

        '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': lambda x: x,

        'rest_framework_field_class': A2ImageDRFField,

        'rest_framework_field_kwargs': {

            'read_only': True,

            },

        'value_is_relative_uri': True,

    },

            self.create_custom_attributes,

    def create_custom_attributes(self, app_config, verbosity=2, interactive=True,

        attrs['avatar_picture'], created = Attribute.objects.get_or_create(

            name='avatar_picture',

            defaults={'kind': 'image',

                      'label': _('Avatar picture'),

                      'required': False,

                      'asked_on_registration': False,

                      'user_editable': True,

                      'user_visible': True})

            for at in attrs:

                serialize = get_kind(at.kind).get('serialize')

                    attribute=attrs[at],

                        'content': serialize(getattr(user, at, None))

    def to_json(self, request=None):

            if request:

                d[str(av.attribute.name)] = av.to_python(request)

            else:

                d[str(av.attribute.name)] = av.to_python()

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)

    def to_python(self, request=None):

        kind = self.attribute.get_kind()

        deserialize = kind['deserialize']

        content = self.content

        if request and kind.get('value_is_relative_uri'):

            content = request.build_absolute_uri(content)

        return deserialize(content)

MEDIA_ROOT = 'media'

MEDIA_URL = '/media/'

    'sorl.thumbnail',

{% load thumbnail %}

{% load authentic2 %}

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

                  {% get_image_url attribute.values.0 request as img_url %}

                  {% thumbnail img_url img_dimensions crop=img_cropping as thumb_im %}

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

                  {% endthumbnail %}

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

from django import template

register = template.Library()

@register.assignment_tag

def get_image_url(relative_uri, request):

    try:

        return request.build_absolute_uri(relative_uri)

    except:

        return ''

from django.views.static import serve as media_serve

    urlpatterns += [

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

        'document_root': settings.MEDIA_ROOT})

    ]

import fcntl

import os

import tempfile

from django.core.files.storage import default_storage

def _store_image(in_memory_image, owner_uuid, attr_label):

    from hashlib import md5

    logger = logging.getLogger(__name__)

    img_media_dir = '{label}/{uuid_short}/'.format(

            label=attr_label,

            uuid_short=owner_uuid[0:4])

    img_media_path = '{imdir}/{uuid}{hexdigest}.{ext}'.format(

            imdir=img_media_dir,

            uuid=owner_uuid,

            hexdigest = md5(in_memory_image.read()).hexdigest(),

            ext=in_memory_image.image.format)

    if not default_storage.exists(img_media_dir):

        os.makedirs(default_storage.path(img_media_dir))

    with open(default_storage.path(img_media_path), 'wb') as f:

        try:

            fcntl.lockf(f, fcntl.LOCK_EX | fcntl.LOCK_NB)

            with tempfile.NamedTemporaryFile(

                    mode='wb',

                    dir=default_storage.path(img_media_dir),

                    delete=False) as temp:

                in_memory_image.seek(0)

                temp.write(in_memory_image.read())

                temp.flush()

                os.rename(temp.name, default_storage.path(img_media_path))

        except:

            logger.error("Couldn't store file {}".format(img_media_path))

        finally:

            fcntl.lockf(f, fcntl.LOCK_UN)

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

    for value in values:

        # Direct URI <-> file location correspondence

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

        if not local_file:

            continue

        media_file = default_storage.path(local_file)

        try:

            os.remove(media_file)

            value.delete()

        except:

            logger.error("Couldn't delete image {}".format(media_file))

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

    uri = ''

    if isinstance(image, basestring):

        uri = 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)

            uri = os.path.join(settings.MEDIA_URL, img_media_path)

    return uri

        from . import attribute_kinds

            'img_dimensions': attribute_kinds.get_image_dimensions(),

            'img_cropping': attribute_kinds.get_image_cropping(),

            'host': request.build_absolute_uri('/')[0:-1],

@pytest.fixture(autouse=True)

def authentic_settings(settings, tmpdir):

    settings.MEDIA_ROOT = str(tmpdir)