def __call__(self, request):
""" Traiter la requête """
if request.user.is_superuser and settings.STATIC_URL not in request.path:
if IMPERSONATE_PARAMETER in request.GET and SESSION_ITEM not in request.session:
request.session[SESSION_ITEM] = request.GET[
IMPERSONATE_PARAMETER]
record.send(None,
actor=request.user,
action='user.impersonate',
target=request.GET[IMPERSONATE_PARAMETER])
elif EXIT_PARAMETER in request.GET and SESSION_ITEM in request.session:
del request.session[SESSION_ITEM]
messages.info(
request,
_("{name}, your impersonation session has been properly shut down."
).format(name=request.user.get_short_name()))
return HttpResponseRedirect(
remove_get_parameter(request, EXIT_PARAMETER))
if SESSION_ITEM in request.session:
try:
request.user = get_user_model().objects.active().get(
username__iexact=request.session[SESSION_ITEM])
messages.info(
request,
_("""You are viewing {path} as {name}. <a href="?{exit}">Quit</a>"""
).format(name=request.session[SESSION_ITEM],
path=request.path,
exit=EXIT_PARAMETER))
except ObjectDoesNotExist:
messages.error(
request,
_("There is no active user with the username {name}.").
format(name=request.session[SESSION_ITEM]))
del request.session[SESSION_ITEM]
return self.get_response(request)
def activation_check(sender, user, request, failed, **kwargs):
""" Traiter une activation réussie ou échouée """
if failed is False:
record.send(None, actor=user, action='user.activation.user')
if request is not None:
if getattr(settings, 'USER_LOGIN_ON_ACTIVATION', True) is True:
# Accueillir l'utilisateur avec un message et le connecter
from scoop.user.models import User
messages.success(
request,
_("Congratulations! Your account is activated, you are now logged in."
))
User.sign(request,
None,
logout=False,
fake=False,
direct_user=user)
else:
messages.success(
request,
_("Congratulations! Your account is activated, you can now log in."
))
else:
if request is not None:
messages.error(request,
_("This activation code is invalid."),
extra_tags="danger")
def flag_creation(sender, flag, **kwargs):
""" Consigner la création d'un nouveau signalement """
if flag.author is not None:
record.send(None,
actor=flag.author,
action='rogue.create.flag',
target=flag.content_object)
def picture_deleted(sender, instance, **kwargs):
""" Traiter une image après sa suppression """
record.send(None,
actor=instance.author,
action='content.delete.picture',
target=instance)
if instance.content_object and instance.content_object._meta.model_name not in TARGET_MODELS_EXCLUDE_FROM_UPDATE:
instance.content_object.save()
def lock_content(request, content):
""" Verrouiller un contenu contre les modifications """
if content.lock():
Alert.objects.alert(content.get_authors(), 'content.content.lock', 'notification', {'content': content})
messages.success(request, _("The content was locked and protected from user interaction."))
record.send(Content, request.user, 'content.lock.content', content)
return True
return False
def send_negotiation(sender, source, target, negotiation, **kwargs):
""" Traiter une nouvelle négociation de discussion """
record.send(None,
actor=source,
action='messaging.send.negotiation',
target=target)
# Automatiquement autoriser la négociation si l'utilisateur a la permission
if source.has_perm('messaging.can_bypass_negotiation'):
negotiation.accept()
def unlike(self, item, author):
""" Ne plus liker un objet """
if author and author.has_perm('social.can_like'):
item_type = ContentType.objects.get_for_model(item)
deleted_count = self.filter(author=author, content_type=item_type, object_id=item.pk).delete()
if deleted_count > 0:
record.send(None, actor=author, action='social.unlike', target=item)
return True
return False
def like(self, item, author):
""" Liker un objet """
if author and author.has_perm('social.can_like'):
item_type = ContentType.objects.get_for_model(item)
_, created = self.get_or_create(author=author, content_type=item_type, object_id=item.pk)
if created is True:
record.send(None, actor=author, action='social.like', target=item)
return created
return False
def login_actions(sender, request, user, **kwargs):
""" Traiter la connexion d'un utilisateur """
# Changer l'expiration de la session
timeout = ConfigurationForm.get_option_for(user, 'session_timeout')
request.session.set_expiry(timedelta(seconds=timeout))
logins = user.profile.get_data('logins', 0)
user.profile.set_data('logins', logins + 1, save=True)
messages.success(request, _("Hello, {name}!").format(name=capfirst(user)))
# Actions publiques et enregistrements
record.send(None, actor=user, action='user.login')
def default_post_send(sender, author, message, request, **kwargs):
""" Traiter un message qui vient d'être envoyé """
if request is not None:
messages.success(request, _("Message sent successfully"))
getattr(check_message, 'delay')(sender)
# Mettre à jour le nombre de messages envoyés par user
Recipient.objects.update_counter(author, message.thread)
record.send(None,
actor=author,
action='messaging.create.message',
target=message)
return True
def picture_created(sender, instance, raw, created, using, update_fields,
**kwargs):
""" Traiter une image après son enregistrement """
if created:
Animation.objects.create_from_animation(instance)
instance.resize()
instance.fix_exif()
instance.optimize()
instance.set_correct_extension()
instance.update_size()
record.send(sender,
actor=instance.author,
action='content.create.picture',
target=instance)
# Réenregistrer l'objet lié (généralement Picturable)
if instance.content_object and instance.content_object._meta.model_name not in TARGET_MODELS_EXCLUDE_FROM_UPDATE:
instance.content_object.save()
def remove_pictures(request, users):
""" Retirer toutes les images d'un profil """
users = make_iterable(users)
destroyed = []
for user in users:
pictures = user.profile.get_pictures()
count = pictures.count()
if count > 0:
Alert.objects.alert(user, 'user.profile.picture.invalid', 'notification', {'count': count, 'pictures': pictures})
record.send(get_user_model(), request.user, 'content.delete.picture', user)
pictures.delete()
destroyed.append(user)
if destroyed:
messages.success(request, humanize_join(destroyed, 3, _("user has images removed;users have images removed")))
return True
else:
messages.info(request, _("No picture has to be deleted."))
return False
def accept_negotiation(sender, source, target, negotiation, **kwargs):
""" Traiter une négociation acceptée """
from scoop.messaging.models import Thread
# Créer un enregistrement
record.send(None,
actor=target,
action='messaging.accept.negotiation',
target=source)
subject = _("Discussion between {0} and {1}").format(target, source)
# Créer le nouveau sujet entre les deux participants
thread_info = Thread.objects.new(target, [source],
subject,
None,
None,
closed=False,
unique=False,
as_mail=False,
force=False)
thread_info['thread'].add_bot_message('negotiation-accepted',
as_mail=False,
data={'target': target})
return thread_info['thread']
def deny_negotiation(sender, source, target, negotiation, **kwargs):
""" Traiter une négociation refusée """
record.send(None,
actor=target,
action='messaging.deny.negotiation',
target=source)
def default_post_thread(sender, author, thread, **kwargs):
""" Traiter la création d'un nouveau thread """
record.send(None, actor=author, action='messaging.create.thread', target=thread)
def logout_actions(sender, request, user, **kwargs):
""" Traiter la déconnexion d'un utilisateur """
messages.success(request, _("Thanks for visiting."))
record.send(None, actor=user, action='user.logout')
def demotion_actions(sender, user, **kwargs):
""" Traiter un utilisateur déchu de son statut """
record.send(None, actor=user, action='user.demote')
def profile_is_banned(sender, user, **kwargs):
""" Traiter lorsqu'un profil est banni """
record.send(user, 'user.ban.user', user)
