Produits Entr'ouvert » Authentic 2

    u = request.user

    if u.is_anonymous():

    return u.to_json(request)

from .utils import image_serialize

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" # Django 1.11 only todo

    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

            serialize_eval_kwargs = self.get_kind().get('serialize_eval_kwargs', {})

            if serialize_eval_kwargs:

                kwargs = dict()

                for key, flat_value in serialize_eval_kwargs.items():

                    evalue = eval(flat_value)

                    kwargs.update({key: evalue})

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

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

                {% if attribute.attribute.name == 'avatar_picture' %}

                    <img class="avatar_picture" src="{{ attribute.values.0 }}">

                {% else %}

                    <img src="{{ attribute.values.0 }}">

                {% endif %}

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

    urlpatterns += [

        url(r'^media/(?P<path>.*)$', 'django.views.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):

    logger = logging.getLogger(__name__)

    digest = md5(in_memory_image.read())

    img_id = digest.hexdigest()

    img_ext = in_memory_image.image.format

    img_media_dir = 'avatars/{oid}/'.format(oid=owner_uuid)

    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)

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

    return uri