Example #1
0
    def test_post_should_not_login_if_user_is_not_active(self):
        """
        In Django >= 1.10 authenticate() returns None if
        user is inactive, while in Django < 1.10 authenticate()
        succeeds if user is inactive.
        """
        user = create_user()
        data = {
            'username': user.username,
            'password': user.raw_password,
        }
        user.is_active = False
        user.save()
        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)

        if django.VERSION >= (1, 10):
            expected_errors = [djoser.constants.INVALID_CREDENTIALS_ERROR]
        else:
            expected_errors = [djoser.constants.INACTIVE_ACCOUNT_ERROR]

        self.assert_status_equal(response, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(response.data['non_field_errors'], expected_errors)
        self.assertFalse(self.signal_sent)
Example #2
0
 def ready(self):
     from c3nav.editor.models import ChangeSet
     from c3nav.editor.signals import set_changeset_author_on_login
     post_save.connect(ChangeSet.object_changed_handler)
     post_delete.connect(ChangeSet.object_changed_handler)
     m2m_changed.connect(ChangeSet.object_changed_handler)
     user_logged_in.connect(set_changeset_author_on_login)
Example #3
0
def login_as_user(request, user_id):
    userobj = authenticate(su=True, user_id=user_id)
    if not userobj:
        raise Http404("User not found")

    exit_users_pk = request.session.get("exit_users_pk", default=[])
    exit_users_pk.append(
        (request.session[SESSION_KEY], request.session[BACKEND_SESSION_KEY]))

    user_logged_in.disconnect(update_last_login)
    try:
        if not custom_login_action(request, userobj):
            login(request, userobj)
    finally:
        user_logged_in.connect(update_last_login)
    request.session["exit_users_pk"] = exit_users_pk

    if hasattr(settings, 'SU_REDIRECT_LOGIN'):
        warnings.warn(
            "SU_REDIRECT_LOGIN is deprecated, use SU_LOGIN_REDIRECT_URL",
            DeprecationWarning,
        )

    return HttpResponseRedirect(
        getattr(settings, "SU_LOGIN_REDIRECT_URL", "/"))
Example #4
0
    def test_post_should_login_user(self):
        user = create_user()
        data = {"username": user.username, "password": user.raw_password}
        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)

        self.assert_status_equal(response, status.HTTP_200_OK)
        self.assertEqual(response.data["auth_token"], user.auth_token.key)
        self.assertTrue(self.signal_sent)
Example #5
0
    def test_post_should_not_login_if_user_is_not_active(self):
        user = create_user()
        data = {"username": user.username, "password": user.raw_password}
        user.is_active = False
        user.save()
        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)

        self.assert_status_equal(response, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(response.data["non_field_errors"], [djoser.constants.INACTIVE_ACCOUNT_ERROR])
        self.assertFalse(self.signal_sent)
Example #6
0
    def test_post_should_login_user(self):
        user = create_user()
        data = {
            'username': user.username,
            'password': user.raw_password,
        }
        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)

        self.assert_status_equal(response, status.HTTP_200_OK)
        self.assertEqual(response.data['auth_token'], user.auth_token.key)
        self.assertTrue(self.signal_sent)
Example #7
0
def impersonate(request, user_id):
    """ Allows a superuser to impersonate another user. """
    admin_user = request.user
    user = User.objects.get(id=user_id)

    # Login as the specified user
    user.backend = 'django.contrib.auth.backends.ModelBackend'
    user_logged_in.disconnect(update_last_login)
    login(request, user)
    user_logged_in.connect(update_last_login)

    request.session[IMPERSONATED_BY_KEY] = admin_user.id
    request.session[IMPERSONATING_KEY] = user.id
    messages.success(request, 'Impersonation successful.')
    return HttpResponseRedirect(reverse('home'))
Example #8
0
    def test_post_with_sanitizers(self):
        user = create_user(**{'username': '******'})
        data = {
            'username': '******',
            'password': user.raw_password,
        }

        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)

        self.assert_status_equal(response, status.HTTP_200_OK)
        self.assertEqual(response.data['auth_token'], user.auth_token.key)
        self.assertTrue(self.signal_sent)
Example #9
0
    def test_post_should_not_login_if_user_is_not_active(self):
        user = create_user()
        data = {
            'username': user.username,
            'password': user.raw_password,
        }
        user.is_active = False
        user.save()
        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)

        self.assert_status_equal(response, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(response.data['non_field_errors'], [djoser.constants.INVALID_CREDENTIALS_ERROR])
        self.assertFalse(self.signal_sent)
Example #10
0
    def test_post_should_not_login_if_user_is_not_active(self):
        user = create_user()
        data = {
            'username': user.username,
            'password': user.raw_password,
        }
        user.is_active = False
        user.save()
        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)

        self.assert_status_equal(response, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(response.data['non_field_errors'], [djoser.constants.INACTIVE_ACCOUNT_ERROR])
        self.assertFalse(self.signal_sent)
Example #11
0
    def test_post_should_login_user(self):
        user = create_user()
        previous_last_login = user.last_login
        data = {
            'username': user.username,
            'password': user.raw_password,
        }
        user_logged_in.connect(self.signal_receiver)
        request = self.factory.post(data=data)

        response = self.view(request)
        user.refresh_from_db()

        self.assert_status_equal(response, status.HTTP_200_OK)
        self.assertEqual(response.data['auth_token'], user.auth_token.key)
        self.assertNotEqual(user.last_login, previous_last_login)
        self.assertTrue(self.signal_sent)
Example #12
0
    def test_login_by_email(self):
        # starting test without allauth app
        settings.INSTALLED_APPS.remove('allauth')

        payload = {"email": self.EMAIL.lower(), "password": self.PASS}
        # there is no users in db so it should throw error (400)
        self.post(self.login_url, data=payload, status_code=400)

        self.post(self.password_change_url, status_code=403)

        # create user
        user = get_user_model().objects.create_user(self.USERNAME, self.EMAIL,
                                                    self.PASS)

        # test auth by email

        user_logged_in.connect(self.on_login)
        self.post(self.login_url, data=payload, status_code=200)
        self.assertTrue(self.signal_sent)
        self.assertEqual('key' in self.response.json.keys(), True)
        self.token = self.response.json['key']

        # test auth by email in different case
        payload = {"email": self.EMAIL.upper(), "password": self.PASS}
        self.post(self.login_url, data=payload, status_code=200)
        self.assertEqual('key' in self.response.json.keys(), True)
        self.token = self.response.json['key']

        # test inactive user
        user.is_active = False
        user.save()
        self.post(self.login_url, data=payload, status_code=400)

        # test wrong email/password
        payload = {"email": 't' + self.EMAIL, "password": self.PASS}
        self.post(self.login_url, data=payload, status_code=400)

        # test empty payload
        self.post(self.login_url, data={}, status_code=400)

        # bring back allauth
        settings.INSTALLED_APPS.append('allauth')
Example #13
0
    def test_post_should_not_login_if_user_is_not_active(self):
        """
        In Django >= 1.10 authenticate() returns None if
        user is inactive, while in Django < 1.10 authenticate()
        succeeds if user is inactive.
        """
        user = create_user()
        data = {"username": user.username, "password": user.raw_password}
        user.is_active = False
        user.save()
        user_logged_in.connect(self.signal_receiver)

        response = self.client.post(self.base_url, data)

        if django.VERSION >= (1, 10):
            expected_errors = [settings.CONSTANTS.messages.INVALID_CREDENTIALS_ERROR]
        else:
            expected_errors = [settings.CONSTANTS.messages.INACTIVE_ACCOUNT_ERROR]

        self.assert_status_equal(response, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(response.data["non_field_errors"], expected_errors)
        self.assertFalse(self.signal_sent)
Example #14
0
class UserSession(models.Model):
    user = models.ForeignKey(Userreg,
                             on_delete=models.CASCADE,
                             related_name='user_id_session')
    session = models.ForeignKey(Session, on_delete=models.CASCADE)

    def user_logged_in_handler(request, customuser, **kwargs):
        if not request.session.session_key:
            request.session.save()
        session_id = request.session.session_key
        UserSession.objects.get_or_create(user=customuser,
                                          session_id=session_id)

    user_logged_in.connect(user_logged_in_handler)
Example #15
0
    def test_allauth_login_with_username(self):
        payload = {"username": self.USERNAME, "password": self.PASS}
        # there is no users in db so it should throw error (400)
        user_logged_in.connect(self.on_login)
        self.post(self.login_url, data=payload, status_code=400)
        self.assertFalse(self.signal_sent)

        self.post(self.password_change_url, status_code=403)
        self.assertFalse(self.signal_sent)

        # create user
        user = get_user_model().objects.create_user(self.USERNAME, '',
                                                    self.PASS)

        self.post(self.login_url, data=payload, status_code=200)
        self.assertEqual('key' in self.response.json.keys(), True)
        self.assertTrue(self.signal_sent)
        self.token = self.response.json['key']

        self.signal_sent = False
        self.post(self.password_change_url, status_code=400)
        self.assertFalse(self.signal_sent)

        # test inactive user
        user.is_active = False
        user.save()
        self.post(self.login_url, data=payload, status_code=400)
        self.assertFalse(self.signal_sent)

        # test wrong username/password
        payload = {"username": self.USERNAME + '?', "password": self.PASS}
        self.post(self.login_url, data=payload, status_code=400)
        self.assertFalse(self.signal_sent)

        # test empty payload
        self.post(self.login_url, data={}, status_code=400)
        self.assertFalse(self.signal_sent)
Example #16
0
class LoggedUser(models.Model):
    user = models.ForeignKey(User, primary_key=True, on_delete=models.CASCADE)

    def __unicode__(self):
        return self.user.username

    def login_user(sender, request, user, **kwargs):
        LoggedUser(user=user).save()

    def logout_user(sender, request, user, **kwargs):
        try:
            u = LoggedUser.objects.get(user=user)
            u.delete()
        except LoggedUser.DoesNotExist:
            pass

    user_logged_in.connect(login_user)
    user_logged_out.connect(logout_user)
Example #17
0
class UserSession(models.Model):

    user = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
    session = models.ForeignKey(Session, on_delete=models.SET_NULL, null=True)
    loggedin = models.DateTimeField(auto_now_add=True)
    loggedout = models.DateTimeField(default=None, null=True)
    headers = JSONField(encoder=SafeEncoder, default=dict)

    def __str__(self):
        return self.user.username

    def login_user(sender, request, user, **kwargs):
        """Log User Session creation"""
        UserSession(user=user,
                    session_id=request.session.session_key,
                    headers=request.META).save()

    def logout_user(sender, request, user, **kwargs):
        """Log User Session destruction"""
        try:
            u = UserSession.objects.get(user=user,
                                        session_id=request.session.session_key)
            u.loggedout = timezone.now()
            u.save()
            # u.delete()
        except UserSession.DoesNotExist:
            pass

    # Event binding:
    user_logged_in.connect(login_user)
    user_logged_out.connect(logout_user)

    def elapsed(self):
        """Elapsed time since logged in"""
        if self.loggedout:
            return self.loggedout - self.loggedin
        else:
            return timezone.now() - self.loggedin

    def is_active(self):
        """Is the session active"""
        return (self.loggedout is None) or not (self.session_id is None)
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, null=True)
    login_count = models.PositiveIntegerField(default=0)
    time_spent = models.FloatField(default=0)  # in minutes
    login_status = models.BooleanField(default=False)

    def login_user(sender, request, user, **kwargs):
        user.userprofile.login_count = user.userprofile.login_count + 1
        user.userprofile.login_status = True
        user.userprofile.save()

    def logout_user(sender, request, user, **kwargs):
        user.userprofile.login_status = False
        # time difference between logout time and last login is added to time spent in minutes
        user.userprofile.time_spent = (timezone.now() -
                                       user.last_login).seconds / 60
        user.userprofile.save()

    user_logged_in.connect(login_user)
    user_logged_out.connect(logout_user)
Example #19
0
class Perfiles(models.Model):
    nombre = models.CharField(max_length=20)
    apellido = models.CharField(max_length=25)
    telefono = models.IntegerField()
    correo = models.EmailField(max_length=70)
    activation_key = models.CharField(max_length=40, blank=True)
    date_key_expires = models.DateTimeField(default=timezone.now)
    usuario = models.OneToOneField(User)

    def update_last_login(sender, user, **kwargs):
        """
            A signal receiver which updates the last_login date for
            the user logging in.
        """
        user.last_login = timezone.now()
        user.save(update_fields=['last_login'])

    user_logged_in.connect(update_last_login)

    def __unicode__(self):
        return self.usuario.username
            'text':
            json.dumps({
                'username': self.user.username,
                'activity_type': 'notification',
                'activity': activity
            })
        })


def create_user_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance)


def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()


def on_user_login(sender, **kwargs):
    Profile.objects.get(user=kwargs['user']).notify_login()


def on_user_logout(sender, **kwargs):
    Profile.objects.get(user=kwargs['user']).notify_logout()


post_save.connect(create_user_profile, sender=User)
post_save.connect(save_user_profile, sender=User)
user_logged_in.connect(on_user_login, sender=User)
user_logged_out.connect(on_user_logout, sender=User)
Example #21
0
    """
    if created:
        UserProfile.objects.create(user=instance)
        Membership.objects.create(user=instance)


post_save.connect(post_save_create_user_and_membership_profile, sender=User)


def post_membership_save_status_update(sender, instance, created, *args,
                                       **kwargs):
    """ updates membership once profile is created  or edited """

    user_profile = UserProfile.objects.get(user=instance.user)
    user_profile.update_user_membership_profile()


post_save.connect(post_membership_save_status_update, sender=Membership)


def check_user_membership_status(sender, request, user, *args, **kwargs):
    #if user can log in, then profile was created

    #update users membership once user logs in

    loged_in_user_profile = UserProfile.objects.get(user=user)
    loged_in_user_profile.update_user_membership_profile()


user_logged_in.connect(check_user_membership_status)
Example #22
0
    return user_profile


def check_profile(sender, user: str, request, **kwargs):
    """
    On first time log in check if there is a profile and if there are data entries from a person with name user in the
    profile.
    :param sender:
    :param user:
    :param request:
    :param kwargs:
    """
    user_obj = User.objects.get(username=user)
    if Profile.objects.filter(user__username=user).exists():  # if user has a profile
        user_profile = Profile.objects.get(user__username=user)
        if user_profile.checkedAssociation:  # Profile should be filled, so there is nothing to do.
            pass
        elif user_profile.metacatalogPerson_id:  # no Association for data checked, so check if there is data now.
            # TODO: implement this! __assign_data()
            __assign_data(user_obj, user_profile)
            pass
        else:  # only user in profile, so assign_person first
            __assign_data(user_obj, user_profile)
            #     print('\033[91mYour user needs first and last name to associate user with data.\033[0m')
    else:  # there is no profile at all for this user
        user_profile = __assign_person(user)
        __assign_data(user_obj, user_profile)


user_logged_in.connect(check_profile)

class User(AbstractBaseUser):
    """Main user model in app"""
    username = models.CharField(max_length=100, unique=True)
    email = models.EmailField(max_length=100, unique=True)
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)
    USERNAME_FIELD = 'username'
    REQUIRED_FIELDS = ['email']
    objects = UserManager()

    def __str__(self):
        return self.username

    def has_perm(self, perm, obj=None):
        """Does the user have a specific permission?"""
        return self.is_admin

    def has_module_perms(self, app_label):
        """Does the user have permissions to view the app `app_label`?"""
        return self.is_admin

    @property
    def is_staff(self):
        """Is the user a member of staff?"""
        return self.is_admin


user_logged_in.connect(update_last_login, dispatch_uid="update_last_login")
Example #24
0
from django.contrib.auth import user_logged_in, user_logged_out
from django.contrib.staticfiles import finders
from django.contrib.staticfiles.templatetags.staticfiles import static

from rest_framework.authtoken.models import Token


def login_signal(sender, user, request, **kwargs):
    token = Token.objects.get_or_create(user=user)
    request.session['token'] = token[0].key
    if finders.find('logo/logo.png'):
        request.session['logo_existe'] = True


def logout_signal(sender, user, request, **kwargs):
    request.session['token'] = None
    request.session['logo_existe'] = False


user_logged_in.connect(login_signal)
user_logged_out.disconnect(logout_signal)
Example #25
0
    logUsuario.tipo_login = "******"
    logUsuario.dia = hoydia()
    logUsuario.hora = hoyhora()
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    logUsuario.ip = ip
    logUsuario.save()
    request.session['0'] = 'bar'
    usuario = AuthUser.objects.get(id=userInstance.id)
    usuario.login = True
    usuario.save()

user_logged_in.connect(do_loginIn)

def do_login_failed(sender, **kwargs):
    print(sender)

user_login_failed.connect(do_login_failed)


def do_loginOut(sender, user, request, **kwargs):
    userInstance = AuthUser.objects.get(username=user)
    logUsuario = LogUsuarios()
    logUsuario.id_usuario = userInstance.id
    logUsuario.passw = userInstance.password
    logUsuario.nombre_usuario = user
    logUsuario.es_super_usuario = userInstance.is_superuser
    logUsuario.primer_nombre = userInstance.first_name
Example #26
0
    class Meta:
        unique_together = (("usuario", "vista", "opcion"), )

    def __str__(self):

        return "{} en {} del usuario {}".format(self.opcion, self.vista,
                                                self.usuario)


class UserSession(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL,
                             on_delete=models.CASCADE)
    session = models.OneToOneField(Session, on_delete=models.CASCADE)


# ----------------------------------------------
# Este código se dispara cuando el usuario inicia sesión y previene que un mismo usuario
# tenga más de una sesión activa simultánea.
def eliminar_sesiones_anteriores(sender, user, request, **kwargs):
    # Eliminar sessiones anteriores
    Session.objects.filter(usersession__user=user).delete()
    # guardar la nueva sesión
    request.session.save()
    # Crear el vínculo entre la sesión y el usuario, para poder eliminarlos cuando se vuelva a ejecutar esta señal
    UserSession.objects.get_or_create(
        user=user, session=Session.objects.get(pk=request.session.session_key))


user_logged_in.connect(eliminar_sesiones_anteriores)
# ---------------------------------------------
Example #27
0
def get_last_login_ip(sender, user, request, **kwargs):
    """
    更新用户最后一次登陆的IP地址
    """
    ip = get_client_ip_from_request(request)
    if ip:
        if RecordIP.objects.filter(last_login_ip=ip, user=user).exists():
            record_id = RecordIP.objects.filter(last_login_ip=ip,
                                                user=user).first()
            record_id.user = user
            record_id.save()
        else:
            RecordIP.objects.create(last_login_ip=ip, user=user)


user_logged_in.connect(get_last_login_ip)


class EmailVerifyRecord(models.Model):
    """
    邮箱验证表
    """
    REGISTER = 'register'
    FORGET = 'forget'
    UPDATE = 'update'
    SEND_TYPE_CHOICES = (
        (REGISTER, u'注册'),
        (FORGET, u'找回密码'),
        (UPDATE, u'修改邮箱'),
    )
    code = models.CharField(verbose_name=u'验证码', max_length=20)
Example #28
0
def my_callback0(sender, **kwargs):
    print("Request finished!+++++")


def my_callback1(sender, **kwargs):
    print("Request Started!+++++")


from django.core.signals import request_finished, request_started

request_finished.connect(my_callback0)
request_started.connect(my_callback1)

from django.contrib.auth import user_logged_in

user_logged_in.connect(my_callback)

###############################################################################

from django import forms


class ExamDocumentForm(forms.Form):
    docfile = forms.FileField(label='Select a file')


def list(request):
    # Handle file upload
    if request.method == 'POST':
        form = ExamDocumentForm(request.POST, request.FILES)
        if form.is_valid():
Example #29
0
    @classmethod
    def user_logged_in(cls, sender, request, user, **kwargs):
        application = getattr(request, 'client', None)
        if not application:
            return
        if user.username in cls.ignored_usernames:
            return
        cls.objects.create(user=user, application=application)

    def __str__(self):
        return '%s logged into %s' % (self.user.username,
                                      self.application.name)


user_logged_in.connect(Login.user_logged_in)


class FailedLoginAttemptManager(models.Manager):
    def is_locked_out(self, user, client=None):
        failed_attempts = self.get_queryset().filter(user=user)
        if client:
            failed_attempts = failed_attempts.filter(application=client)
        failed_attempt_count = failed_attempts.count()
        if not failed_attempt_count:
            return False

        if failed_attempt_count >= settings.MTP_AUTH_LOCKOUT_COUNT:
            last_failed_attempt = failed_attempts.first()
            lockout_cutoff = now() - datetime.timedelta(
                seconds=settings.MTP_AUTH_LOCKOUT_LOCKOUT_PERIOD)
    }

    @classmethod
    def user_logged_in(cls, sender, request, user, **kwargs):
        application = getattr(request, 'client', None)
        if not application:
            return
        if user.username in cls.ignored_usernames:
            return
        cls.objects.create(user=user, application=application)

    def __str__(self):
        return '%s logged into %s' % (self.user.username, self.application.name)


user_logged_in.connect(Login.user_logged_in)


class FailedLoginAttemptManager(models.Manager):
    def is_locked_out(self, user, client=None):
        failed_attempts = self.get_queryset().filter(user=user)
        if client:
            failed_attempts = failed_attempts.filter(application=client)
        failed_attempt_count = failed_attempts.count()
        if not failed_attempt_count:
            return False

        if failed_attempt_count >= settings.MTP_AUTH_LOCKOUT_COUNT:
            last_failed_attempt = failed_attempts.first()
            lockout_cutoff = now() - datetime.timedelta(
                seconds=settings.MTP_AUTH_LOCKOUT_LOCKOUT_PERIOD
Example #31
0
def merge_carts(sender, user, request, **kwargs):
    try:
        session_cart = Cart.objects.get(session=request.session.session_key)
        user_cart = Cart.objects.get_or_create(user=user)[0]
        if user_cart.id != session_cart.id:
            for item in session_cart.items.all():
                item.cart = user_cart
                item.save()
            session_cart.delete()
            user_cart.session = request.session.session_key
            user_cart.save()
    except Cart.DoesNotExist:
        pass


user_logged_in.connect(merge_carts)


def cart_changed_listener(sender, instance, **kwargs):
    if not settings.CART_CHANGED_EMAIL_SEND_AFTER and\
            instance.user is not None:
        return
    for time in settings.CART_CHANGED_EMAIL_SEND_AFTER.split(','):
        pending_tasks = task_manager.get_pending_tasks(
            'checkout.jobs.forgotten_cart_send_email_job')
        email_jobs_exists = False
        for task_id in pending_tasks:
            task = task_manager.get_task_instance(task_id)
            if task.kwargs.get('run_after') == time:
                email_jobs_exists = True
                break
Example #32
0
import logging
import json

from django.contrib.auth import user_logged_in
from django.http import QueryDict
from rest_framework import status

logger = logging.getLogger("project")


def listener_logged_in(sender, user=None, **kwargs):
    VMSRequest.user_id = user.id


user_logged_in.connect(listener_logged_in)


class VMSRequest(object):
    ENV_HEADERS = ('X-Varnish', 'X-Request-Start', 'X-Heroku-Queue-Depth',
                   'X-Real-Ip', 'X-Forwarded-Proto', 'X-Forwarded-Protocol',
                   'X-Forwarded-Ssl', 'X-Heroku-Queue-Wait-Time',
                   'X-Forwarded-For', 'X-Heroku-Dynos-In-Use',
                   'X-Forwarded-For', 'X-Forwarded-Protocol',
                   'X-Forwarded-Port', 'Runscope-Service')
    enable_activity_log = True
    user_id = None
    request = None
    url = None
    view = None
    response = None
Example #33
0
        user_settings = user.settings
    except (AttributeError, ObjectDoesNotExist):
        return

    try:
        tz = user_settings.tz
    except AttributeError:
        return

    if tz:
        request.session['django_timezone'] = force_text(tz)
        timezone.activate(tz)


user_logged_in.connect(
    set_user_timezone_on_login,
    dispatch_uid='aldryn_accounts:set_user_timezone_on_login')


def set_username_if_not_exists(sender, **kwargs):
    user = kwargs.get('instance')
    if isinstance(user, User):
        if not user.username:
            user.username = generate_username()


signals.pre_save.connect(set_username_if_not_exists,
                         dispatch_uid='aldryn_accounts:generate_username')

# TODO: figure this out. actually we'd need to redirect to a url with the language prefix.
# def set_user_preferred_language_on_login(sender, user, request, **kwargs):
Example #34
0
from django.contrib.auth import user_logged_in

from commerce.models.user import UserSession


def user_logged_in_handler(sender, user, request, **kwargs):
    session, created = UserSession.objects.get_or_create(
        user=user,
        session_id=request.session.session_key,
    )

    old_sessions = UserSession.objects.select_related('session').filter(
        user__phone_number=user.phone_number,
        user__deleted_at__isnull=True).exclude(id=session.id, )

    for row in old_sessions:
        if hasattr(row, 'session') and row.session:
            row.session.delete()
        row.delete()


user_logged_in.connect(user_logged_in_handler)
Example #35
0
from django.db import models
from django.contrib.auth import user_logged_in, user_logged_out
from actstream import action

def user_action_in(sender, user, request, **kwargs):
     action.send(user, verb=u'log in')
user_logged_in.connect(user_action_in)

def user_action_out(sender, user, request, **kwargs):
     action.send(user, verb=u'log out')
user_logged_out.connect(user_action_out)

# #sample
# def post_save_action(sender, **kwargs):
#      action.send(kwargs['instance'], verb=u'a user created')
# post_save.connect(post_save_action, sender=User)

class Player(models.Model):
    state = models.IntegerField(default=0)
    
    def __unicode__(self):
        return '#%d' % self.pk