0001-WIP-support-avatar-picture-in-user-profile-26022.patch

Paul Marillonnet, 05 septembre 2018 17:51

Voir les différences: en ligne côte à côte

Subject: [PATCH] WIP support avatar picture in user profile (#26022)

 src/authentic2/attribute_kinds.py             | 12 +++++
 src/authentic2/custom_user/apps.py            | 20 +++++---
 src/authentic2/models.py                      |  9 +++-
 src/authentic2/settings.py                    |  2 +
 .../templates/authentic2/accounts.html        | 18 ++++---
 .../templates/authentic2/accounts_edit.html   |  7 ++-
 src/authentic2/urls.py                        |  4 ++
 src/authentic2/utils.py                       | 51 +++++++++++++++++++
 8 files changed, 108 insertions(+), 15 deletions(-)

     from .plugins import collect_from_plugins
     from . import app_settings
     from .forms import widgets
     from .utils import store_image
     capfirst = allow_lazy(capfirst, unicode)
-...
             'field_class': PhoneNumberField,
             'rest_framework_field_class': PhoneNumberDRFField,
         },
+        {
             'label': _('image'),
             'name': 'image',
             'field_class': forms.ImageField,
             'serialize': store_image,
             'serialize_eval_args' : [
                 "owner.uuid",
             ],
             'deserialize': lambda x: x,
             'rest_framework_field_class': serializers.ImageField,
         },
+    ]

             from django.db.models.signals import post_migrate
             post_migrate.connect(
                 self.create_first_name_last_name_attributes,
                 self.create_custom_attributes,
                 sender=self)
         def create_first_name_last_name_attributes(self, app_config, verbosity=2, interactive=True,
         def create_custom_attributes(self, app_config, verbosity=2, interactive=True,
                                                    using=DEFAULT_DB_ALIAS, **kwargs):
             from django.utils import translation
             from django.utils.translation import ugettext_lazy as _
-...
                           'asked_on_registration': True,
                           'user_editable': True,
                           'user_visible': 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})
             serialize = get_kind('string').get('serialize')
             for user in User.objects.all():
                 for attr_name in attrs:
                 for at in attrs:
                     serialize = get_kind(at.kind).get('serialize')
                     av, created = AttributeValue.objects.get_or_create(
                         content_type=content_type,
                         object_id=user.id,
                         attribute=attrs[attr_name],
                         attribute=attrs[at],
                         defaults={
                             'multiple': False,
                             'verified': False,
                             'content': serialize(getattr(user, attr_name, None))
                             'content': serialize(getattr(user, at, None))
                         })

                         av.verified = verified
                         av.save()
             else:
                 content = serialize(value)
                 if self.get_kind().get('serialize_eval_args'):
                     serialize_args = list()
                     for flat_arg in self.get_kind().get('serialize_eval_args', []):
                         serialize_args.append(eval(flat_arg))
                     content = serialize(value, *serialize_args)
                 else:
                     content = serialize(value)
                 av, created = AttributeValue.objects.get_or_create(
                         content_type=ContentType.objects.get_for_model(owner),
                         object_id=owner.pk,

     DEBUG = False
     DEBUG_DB = False
     MEDIA = 'media'
     MEDIA_ROOT = 'media'
     MEDIA_URL = '/media/'
     # See https://docs.djangoproject.com/en/dev/ref/settings/#allowed-hosts
     ALLOWED_HOSTS = []

               {% for attribute in attributes %}
                 <dt>{{ attribute.attribute.label|capfirst }}&nbsp;:</dt>
                 <dd>
                   {% if attribute.values|length == 1 %}
                     {{ attribute.values.0 }}
                   {% if attribute.attribute.kind == 'image' %}
                     <img src="{{ attribute.values.0 }}">
                   {% else %}
                     <ul>
                       {% for value in attribute.values %}
                         <li>{{ value }}</li>
                       {% endfor %}
                     </ul>
                     {% if attribute.values|length == 1 %}
                       {{ attribute.values.0 }}
                     {% else %}
                       <ul>
                         {% for value in attribute.values %}
                           <li>{{ value }}</li>
                         {% endfor %}
                       </ul>
                     {% endif %}
                   {% endif %}
                 </dd>
               {% endfor %}

     {% endblock %}
     {% block content %}
       <form method="post">
         {% if form.is_multipart %}
           <form enctype="multipart/form-data" method="post">
         {% else %}
           <form method="post">
         {% endif %}
         {% csrf_token %}
         {{ form.as_p }}
         {% if form.instance and form.instance.id %}

         urlpatterns += [
             url(r'^static/(?P<path>.*)$', serve)
+        ]
         urlpatterns += [
             url(r'^media/(?P<path>.*)$', 'django.views.static.serve', {
             'document_root': settings.MEDIA_ROOT})
+        ]
     if settings.DEBUG and 'debug_toolbar' in settings.INSTALLED_APPS:
         import debug_toolbar

     import uuid
     import datetime
     import copy
     import fcntl
     import os
     import tempfile
     from functools import wraps
     from itertools import islice, chain, count
     from importlib import import_module
     from hashlib import md5
     from django.conf import settings
     from django.http import HttpResponseRedirect, HttpResponse
-...
     from django.template.loader import render_to_string, TemplateDoesNotExist
     from django.core.mail import send_mail
     from django.core import signing
     from django.core.files.storage import default_storage
     from django.core.urlresolvers import reverse, NoReverseMatch
     from django.utils.formats import localize
     from django.contrib import messages
-...
             if ou_value is not None:
                 return ou_value
         return default
     def store_image(file_wrapper, owner_uuid):
         logger = logging.getLogger(__name__)
         digest = md5(file_wrapper.read())
         image_uuid = digest.hexdigest()
         image_format = file_wrapper.image.format
         image_folder = default_storage.path('avatars/{oid}'.format(
             oid=owner_uuid))
         image_path = os.path.join(
                 image_folder,
                 "{uuid}.{ext}".format(uuid=image_uuid, ext=image_format))
         uri = os.path.join(settings.MEDIA_URL, 'avatars/{oid}/{uuid}.{ext}'.format(
                 oid=owner_uuid, uuid=image_uuid, ext=image_format))
         try:
             if not os.path.exists(image_folder):
                 os.makedirs(image_folder)
             with open(image_path, 'wb') as f:
                 try:
                     fcntl.lockf(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
                     with tempfile.NamedTemporaryFile(mode='wb', dir=image_folder, delete=False) as temp:
                         try:
                             file_wrapper.seek(0)
                             temp.write(file_wrapper.read())
                             temp.flush()
                             os.rename(temp.name, image_path)
                             pass
                         except:
                             logger.error("Could'nt store image to {}", file_path)
                             os.unlink(temp.name)
                         finally:
                             fcntl.lockf(f, fcntl.LOCK_UN)
                 except:
                     logger.error("Couldn't hold exclusive lock for file {}".format(image_path))
                 finally:
                     fcntl.lockf(f, fcntl.LOCK_UN)
         except IOError:
             return
         return uri
+    -

Projet

Général

Profil

Produits Entr'ouvert » Authentic 2

0001-WIP-support-avatar-picture-in-user-profile-26022.patch