Produits Entr'ouvert » Authentic 2

    python-django-filters (>= 1),

    python-sorl-thumbnail

    python-django-filters (<< 2),

    python-sorl-thumbnail

          'sorl-thumbnail',

          'pillow',

    u = request.user

    if u.is_anonymous():

    return u.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, *args, **kwargs):

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

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

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

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

                {% with request.is_secure|yesno:"https://,http://"|add:request.get_host|add:attribute.values.0 as im_url %}

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

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

                  {% endthumbnail %}

                {% endwith %}

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

                  {{ attribute.values.0 }}

                {% else %}

                  <ul>

                    {% for value in attribute.values %}

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

                    {% endfor %}

                  </ul>

                {% endif %}

    {% if form.is_multipart %}

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

    {% else %}

      <form method="post">

    {% endif %}

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

  {% if form.is_multipart %}

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

  {% else %}

    <form method="post">

  {% endif %}

from django.views.static import serve as static_serve

    urlpatterns += [

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

        'document_root': settings.MEDIA_ROOT})

    ]

import fcntl

import os

import tempfile

from hashlib import md5

from django.core.files.storage import default_storage

def _store_image(in_memory_image, owner_uuid, attr_label):

    logger = logging.getLogger(__name__)

    digest = md5(in_memory_image.read())

    img_id = digest.hexdigest()

    img_ext = in_memory_image.image.format

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

            oid=owner_uuid,

            label=attr_label)

    img_media_path = '{imdir}/{iid}.{ext}'.format(

            imdir=img_media_dir, iid=img_id, ext=img_ext)

    img_abs_path = default_storage.path(img_media_path)

    img_abs_dir = default_storage.path(img_media_dir)

    try:

        if not os.path.exists(img_abs_dir):

            os.makedirs(img_abs_dir)

        with open(img_abs_path, 'wb') as f:

            try:

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

                with tempfile.NamedTemporaryFile(mode='wb', dir=img_abs_dir, delete=False) as temp:

                    try:

                        in_memory_image.seek(0)

                        temp.write(in_memory_image.read())

                        temp.flush()

                        os.rename(temp.name, img_abs_path)

                    except:

                        logger.error("Could'nt store image to {}".format(img_abs_path))

                        os.unlink(temp.name)

            except:

                logger.error("Couldn't hold exclusive lock for file {}".format(img_abs_path))

            finally:

                fcntl.lockf(f, fcntl.LOCK_UN)

    except IOError:

        return

    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("Could'nt 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(),

@pytest.fixture(autouse=True)

def authentic_settings(settings, tmpdir):

        settings.MEDIA_ROOT = str(tmpdir)