示例#1
0
 def test_zinnia_entry_detail_login_password(self):
     user_logged_in.disconnect(update_last_login)
     setup_test_template_loader(
         {'zinnia/entry_detail.html': '',
          'zinnia/login.html': '',
          'zinnia/password.html': ''})
     entry = self.create_published_entry()
     entry.password = '******'
     entry.login_required = True
     entry.save()
     with self.assertNumQueries(4):
         response = self.client.get('/2010/01/01/my-test-entry/')
     self.assertTemplateUsed(response, 'zinnia/login.html')
     with self.assertNumQueries(9):
         response = self.client.post('/2010/01/01/my-test-entry/',
                                     {'username': '******',
                                      'password': '******'})
     self.assertEquals(response.status_code, 200)
     self.assertTemplateUsed(response, 'zinnia/password.html')
     self.assertEquals(response.context['error'], False)
     with self.assertNumQueries(6):
         response = self.client.post('/2010/01/01/my-test-entry/',
                                     {'entry_password': '******'})
     self.assertEquals(response.status_code, 200)
     self.assertTemplateUsed(response, 'zinnia/entry_detail.html')
     restore_template_loaders()
     user_logged_in.connect(update_last_login)
 def connect(self):
   if not self.started:
     user_logged_in.connect(self.logged_in)
     user_logged_out.connect(self.logged_out)
     user_login_failed.connect(self.login_failed)
     self.started = True
   return self
示例#3
0
 def test_zinnia_entry_detail_login_password(self):
     user_logged_in.disconnect(update_last_login)
     self.inhibit_templates('zinnia/entry_detail.html',
                            'zinnia/login.html',
                            'zinnia/password.html')
     entry = self.create_published_entry()
     entry.password = '******'
     entry.login_required = True
     entry.save()
     with self.assertNumQueries(1):
         response = self.client.get(entry.get_absolute_url())
     self.assertTemplateUsed(response, 'zinnia/login.html')
     with self.assertNumQueries(12):
         response = self.client.post(entry.get_absolute_url(),
                                     {'username': '******',
                                      'password': '******'})
     self.assertEqual(response.status_code, 200)
     self.assertTemplateUsed(response, 'zinnia/password.html')
     self.assertEqual(response.context['error'], False)
     with self.assertNumQueries(7):
         response = self.client.post(entry.get_absolute_url(),
                                     {'entry_password': '******'})
     self.assertEqual(response.status_code, 200)
     self.assertTemplateUsed(response, 'zinnia/entry_detail.html')
     user_logged_in.connect(update_last_login)
示例#4
0
def login_user(request, hijacked):
    ''' hijack mechanism '''
    hijacker = request.user
    hijack_history = [request.user._meta.pk.value_to_string(hijacker)]
    if request.session.get('hijack_history'):
        hijack_history = request.session['hijack_history'] + hijack_history

    check_hijack_authorization(request, hijacked)

    backend = get_used_backend(request)
    hijacked.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__)

    # Prevent update of hijacked user last_login
    signal_was_connected = user_logged_in.disconnect(update_last_login)

    # Actually log user in
    login(request, hijacked)

    # Restore signal if needed
    if signal_was_connected:
        user_logged_in.connect(update_last_login)

    post_superuser_login.send(sender=None, user_id=hijacked.pk)  # Send legacy signal
    hijack_started.send(sender=None, hijacker_id=hijacker.pk, hijacked_id=hijacked.pk, request=request)  # Send official, documented signal
    request.session['hijack_history'] = hijack_history
    request.session['is_hijacked_user'] = True
    request.session['display_hijack_warning'] = True
    request.session.modified = True
    return redirect_to_next(request, default_url=hijack_settings.HIJACK_LOGIN_REDIRECT_URL)
示例#5
0
 def setUp(self):
     self.client = Client(enforce_csrf_checks=True)
     self.client.get('/')  # To get the CSRF token for next request
     assert django_settings.CSRF_COOKIE_NAME in self.client.cookies
     self.target_user = User.objects.create(username='******')
     # setup listener
     user_logged_in.connect(update_last_login)
	def test_logged_in(self):
		signal_user = set()
		def login_signal_handler(sender, request, user, **kwargs):
			signal_user.add(user)
		user_logged_in.connect(login_signal_handler)
		u = self.b.register(self.req, email='*****@*****.**')
		self.assertIn(u, signal_user)
示例#7
0
def init_watchers(w):
    for w in WATCH:
        if w == "login":
            user_logged_in.connect(login_action)
        elif w == "logout":
            user_logged_out.connect(logout_action)
        elif w == "login_failed":
            user_login_failed.connect(login_failed)
    return
示例#8
0
def user_logged_in_handler(sender, request, user, **kwargs):
	UserSession.objects.get_or_create(user = user, session_id = request.session.session_key)
	user_logged_in.connect(user_logged_in_handler)
	# session = Session.objects.get(session_key=session_key)
	uid = session.get_decoded().get('_auth_user_id')
	user = User.objects.get(pk=uid)
	lock = System_status.objects.all()[:1].get()
	if lock.status :
		return render(request,'blog/locked.html')
	return HttpResponse(user)
示例#9
0
    def test_login_with_user(self):
        """Login should send user_logged_in signal on successful login."""
        def listener(*args, **kwargs):
            listener.executed = True
        listener.executed = False

        user_logged_in.connect(listener)
        self.client.login(username='******', password='******')
        user_logged_out.disconnect(listener)

        self.assertTrue(listener.executed)
示例#10
0
    def test_login_without_signal(self):
        """Login shouldn't send signal if user wasn't logged in"""
        def listener(*args, **kwargs):
            listener.executed = True
        listener.executed = False

        user_logged_in.connect(listener)
        self.client.login(username='******', password='******')
        user_logged_in.disconnect(listener)

        self.assertFalse(listener.executed)
示例#11
0
def capture_users_metrics(statsd_client):
    gauge_user_count()
    gauge_active_users()

    if not getattr(User, '__metrics_registered', False):
        post_delete.connect(sender=User, receiver=user_deleted)
        post_save.connect(sender=User, receiver=user_created)

        user_logged_in.connect(receiver=logged_in)
        user_logged_out.connect(receiver=logged_out)

        User.__metrics_registered = True
示例#12
0
 def test_last_seen(self):
     self.editor.last_seen = None
     self.editor.save()
     self.client.cookies.clear()
     # login sends dud request without REQUEST dict
     user_logged_in.disconnect(views.set_session_expiry)
     self.client.login(username="******", password="******")
     user_logged_in.connect(views.set_session_expiry)
     self.client.get("/")
     last_seen = Member.objects.get(pk=self.editor.pk).last_seen
     self.assertTrue(last_seen)
     self.client.get("/")
     self.assertEqual(Member.objects.get(pk=self.editor.pk).last_seen, last_seen)
示例#13
0
def no_update_last_login():
    """
    Disconnect any signals to update_last_login() for the scope of the context
    manager, then restore.
    """
    kw = {'receiver': update_last_login}
    kw_id = {'receiver': update_last_login, 'dispatch_uid': 'update_last_login'}

    was_connected = user_logged_in.disconnect(**kw)
    was_connected_id = not was_connected and user_logged_in.disconnect(**kw_id)
    yield
    # Restore signal if needed
    if was_connected:
        user_logged_in.connect(**kw)
    elif was_connected_id:
        user_logged_in.connect(**kw_id)
示例#14
0
 def test_login(self):
     # stuff for detecting if the user got authenticated
     from django.contrib.auth.signals import user_logged_in
     u = User.objects.get(pk=1)
     u.passed = False
     def logged_in(sender, user, **kwargs):
         if user.id == u.id:
             u.passed = True
     user_logged_in.connect(logged_in)
     
     # The test procedure
     self.login()
     time.sleep(2)
     
     # Check the results
     self.assertTrue(u.passed, "The user should be logged in after we finish the login test!")
示例#15
0
    def test_post_should_not_login_when_wrong_credentials(self):
        user = create_user()
        data = {
            'username': '******',
            'password': '******',
            'client': 'my-device',
        }
        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)
        with self.assertRaises(models.Token.DoesNotExist):
            user.auth_tokens.get()
        self.assertFalse(self.signal_sent)
示例#16
0
    def test_post_should_login_user(self):
        user = create_user()
        data = {
            'username': user.username,
            'password': user.raw_password,
            'client': 'my-device',
        }
        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)
        token = user.auth_tokens.get()
        self.assertEqual(response.data['auth_token'], token.key)
        self.assertEqual(data['client'], token.client)
        self.assertTrue(self.signal_sent)
示例#17
0
    def ready(self):
        from django.contrib.auth.models import update_last_login as django_update_last_login
        user_logged_in.disconnect(django_update_last_login)
        from .signals.receivers import update_last_login
        user_logged_in.connect(update_last_login)

        from django.contrib.auth.models import User
        from .signals.receivers import on_user_updated
        pre_save.connect(on_user_updated, sender=User)

        # The django-simple-history model on CourseEnrollment creates performance
        # problems in testing, we mock it here so that the mock impacts all tests.
        if os.environ.get('DISABLE_COURSEENROLLMENT_HISTORY', False):
            import student.models as student_models
            from mock import MagicMock

            student_models.CourseEnrollment.history = MagicMock()
    def test_logout_user(self):
        user_logged_in.connect(self.record_user_logged_in)
        user_logged_out.connect(self.record_user_logged_out)

        user, _ = do_authenticate()

        new_user = User(username='******')
        new_user.backend = 'django.contrib.auth.backends.ModelBackend'
        new_user.save()

        request = RequestFactory().get('/')
        request.session = Client().session
        login(request, new_user)

        user2, _ = do_authenticate(new_user)

        self.assertIsNotNone(user, 'Processed user should not have been None.')
        self.assertEqual(user, user2, 'No new user should have been created.')
        self.assertNotEqual(self.logged_in_user, new_user, 'Second user should have been logged out.')
        self.assertEqual(self.logged_out_user, new_user, 'Second user should have been logged out.')
        self.assertEqual(self.logged_in_user, user, 'First user should have been logged out.')
        self.assertNotEqual(self.logged_out_user, user, 'First user should have been logged out.')
示例#19
0
def login_as(user, request, store_original_user=True):
    """
    Utility function for forcing a login as specific user -- be careful about
    calling this carelessly :)
    """

    # Save the original user pk before it is replaced in the login method
    original_user_pk = request.user.pk

    # Find a suitable backend.
    if not hasattr(user, 'backend'):
        for backend in django_settings.AUTHENTICATION_BACKENDS:
            if user == load_backend(backend).get_user(user.pk):
                user.backend = backend
                break

    # Log the user in.
    if hasattr(user, 'backend'):
        signal_was_connected = False
        if not la_settings.UPDATE_LAST_LOGIN:
            # Prevent update of user last_login
            signal_was_connected = user_logged_in.disconnect(update_last_login)

        try:
            # Actually log user in
            login(request, user)
        finally:
            # Restore signal if needed
            if signal_was_connected:
                user_logged_in.connect(update_last_login)
    else:
        return

    # Set a flag on the session
    if store_original_user:
        messages.warning(request, la_settings.MESSAGE_LOGIN_SWITCH.format(username=user.__dict__[username_field]),
                         extra_tags=la_settings.MESSAGE_EXTRA_TAGS)
        request.session[la_settings.USER_SESSION_FLAG] = signer.sign(original_user_pk)
示例#20
0
 def test_zinnia_entry_detail_login_password(self):
     user_logged_in.disconnect(update_last_login)
     setup_test_template_loader(
         {"zinnia/entry_detail.html": "", "zinnia/login.html": "", "zinnia/password.html": ""}
     )
     entry = self.create_published_entry()
     entry.password = "******"
     entry.login_required = True
     entry.save()
     with self.assertNumQueries(4):
         response = self.client.get("/2010/01/01/my-test-entry/")
     self.assertTemplateUsed(response, "zinnia/login.html")
     with self.assertNumQueries(9):
         response = self.client.post("/2010/01/01/my-test-entry/", {"username": "******", "password": "******"})
     self.assertEquals(response.status_code, 200)
     self.assertTemplateUsed(response, "zinnia/password.html")
     self.assertEquals(response.context["error"], False)
     with self.assertNumQueries(6):
         response = self.client.post("/2010/01/01/my-test-entry/", {"entry_password": "******"})
     self.assertEquals(response.status_code, 200)
     self.assertTemplateUsed(response, "zinnia/entry_detail.html")
     restore_template_loaders()
     user_logged_in.connect(update_last_login)
示例#21
0
	'''When user logged in then check user membership status and perform action accordig to it'''
	membership = user.membership
	if user.on_free_trial:
		#membership end date has passed
		if membership.end_date < timezone.now():
			user.on_free_trial = False
			#update the membership
			membership.type = 'N'

		elif user.is_member:
			sub = stripe.Subscription.retrieve(membership.stripe_subscription_id)
			if sub.status == 'active':
				membership.end_date = datetime.datetime.fromtimestamp(
					sub.current_period_end
					)
				#already true but again set it true if in some case it becomes false
				user.is_member = True
			else:
				user.is_member = False
				#update the membership
				membership.type = 'N'
		else:
			pass

		user.save()
		membership.save()

#link this receiver to the post_save_signal
post_save.connect(post_save_user_receiver, sender=User) 
user_logged_in.connect(user_logged_in_receiver)
示例#22
0
def user_login_time(request, **kwargs):
    x = datetime.now()
    try:
        user = UserLoginLogout.objects.get(USER = request.user, DATE = x.date())
    except: 
        user = UserLoginLogout.objects.create(USER = request.user, DATE = x.date(), LOGIN = x.time())
    return user

def user_location_view(request):
    x = datetime.now()
    if request.is_ajax():
        queryDict = request.GET
        data = dict(queryDict)
        latitude = float(data['latitude'][0])
        longitude = float(data['longitude'][0])

        user_location = UserLocation.objects.create(USER = request.user, DATE = x.date(), LATITUDE = latitude,\
            LONGITUDE = longitude)
    
        return HttpResponse(content_type='json')

def user_logout_time(request, **kwargs):
    x = datetime.now()
    user = UserLoginLogout.objects.get(USER = request.user, DATE = x.date())
    user.LOGOUT = x.time()
    user.save()
    return user


user_logged_in.connect(user_login_time)
user_logged_out.connect(user_logout_time)
示例#23
0
        from_email='*****@*****.**',
        to_emails=reset_password_token.user.email,
    )
    message.dynamic_template_data = {
        'subject': 'Usamodzielnieni: resetowanie hasła',
        'name': reset_password_token.user.first_name,
        'part1': part1,
        'part2': reset_url,
        'part3': part2
    }

    send_mail_via_sendgrid(message)


@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def commit_date_joined(sender, instance, created, **kwargs):
    if created:
        instance.date_joined = timezone.now()


def commit_last_login(sender, user, request, **kwargs):
    user.last_login = timezone.now()


user_logged_in.connect(commit_last_login)


@receiver(pre_delete, sender=Account)
def delete_category_header(sender, instance, using, **kwargs):
    instance.delete_image_if_exists()
示例#24
0
def on_post_save_for_user(sender, **kwargs):
    if kwargs['created']:
        user = kwargs['instance']

        # 환영 이메일 보내기
        send_mail(
            '가입 환영 메일 제목.',
            '가입 환영 메일 내용',
            '*****@*****.**',
            [user.email],
            fail_silently=False,
        )


post_save.connect(on_post_save_for_user, sender=settings.AUTH_USER_MODEL)


class UserSession(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL,
                             on_delete=models.CASCADE,
                             editable=False)
    session_key = models.CharField(max_length=40, editable=False)
    created_at = models.DateTimeField(auto_now_add=True)


def on_user_logged_in(sender, request, user, **kwargs):
    user.is_user_logged_in = True


user_logged_in.connect(on_user_logged_in)
示例#25
0
from tastypie.models import ApiKey
from trees.models import Tree, Image

from django.contrib.auth.signals import user_logged_in
from django.http import HttpResponse
from tastypie.exceptions import ImmediateHttpResponse
from tastypie import http

import pdb


def generate_api_key(sender, user, request, **kwargs):
    ApiKey.objects.get_or_create(user=user)[0].save()


user_logged_in.connect(generate_api_key)


class UnauthenticatedGetAllowedAuthentication(ApiKeyAuthentication):
    """
    Allows GET requests read-only access
    """
    def is_authenticated(self, request, **kwargs):
        if request.method == 'GET':
            return True
        return super(UnauthenicatedGetAllowedAuthentication,
                     self).is_authenticated(request, kwargs)


class CORSResource(object):
    """
示例#26
0
		""" sets a new one if it doesn't exist """
	except UserStripe.DoesNotExist	:

		customer=stripe.Customer.create(
			name=user.username, 
			#email=user.email 
		)
		new_user_stripe=UserStripe.objects.create(
			#the customer json response is where we got the id
			user=user,
			stripe_id=customer.id
		)
	except:
		pass

user_logged_in.connect(get_or_create_stripe)

""" make customers default address"""

class UserDefaultAddress(models.Model):
	user=models.OneToOneField(User,null=True,on_delete=models.CASCADE)
	shipping_address=models.ForeignKey("UserAddress",
		null=True,on_delete=models.CASCADE, related_name='user_default_shipping_address')
	billing_address=models.ForeignKey("UserAddress",
		null=True,on_delete=models.CASCADE, related_name='user_default_billing_address')

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


示例#27
0
    def is_owner(self, instance):
        if self.user in instance.users:
            return True
        else:
            for group in self.user.groups.all():
                if group in instance.groups:
                    return True
        return False

    def __str__(self):
        return "%s profile" % self.user


# Signals
def create_user_profile(sender, instance, created, **kwargs):
    if created and not kwargs.get('raw', False):
        UserProfile.objects.create(user=instance)


post_save.connect(create_user_profile,
                  sender=User,
                  dispatch_uid='create_UserProfile')


def update_session_last_login(sender, user, request, **kwargs):
    if request:
        request.session['LAST_LOGIN_DATE'] = datetime.datetime.now()


user_logged_in.connect(update_session_last_login)
示例#28
0
from registration.signals import user_activated

@receiver(user_activated)
def create_user_profile(sender, user, request, **kwargs):
    user_profile = UserProfile.objects.create(user=user)
    from guardian.shortcuts import assign_perm
    assign_perm('change_userprofile', user, user_profile)
    assign_perm('delete_userprofile', user, user_profile)
    assign_perm('change_user', user, user)

def check_userprofile_details(sender, request, user, **kwargs):
    if not user.first_name:
        request.session['no_name'] = True
    topic_list = TopicFollow.objects.filter(user=user)
    if not topic_list:
        request.session['no_topic'] = True

def create_project_permission(sender, instance, created, **kwargs):
    if created:
        assign_perm('change_project', instance.user, instance)
        assign_perm('delete_project', instance.user, instance)

def create_snippet_permission(sender, instance, created, **kwargs):
    if created:
        assign_perm('change_snippet', instance.user, instance)
        assign_perm('delete_snippet', instance.user, instance)

user_logged_in.connect(check_userprofile_details)
post_save.connect(create_snippet_permission, sender=Snippet)
post_save.connect(create_project_permission, sender=Project)
示例#29
0
    dispatch_uid="create_team_and_keys_for_project",
    weak=False,
)
post_save.connect(
    create_team_member_for_owner,
    sender=Team,
    dispatch_uid="create_team_member_for_owner",
    weak=False,
)
post_save.connect(
    update_document,
    sender=Group,
    dispatch_uid="update_document",
    weak=False,
)
post_save.connect(
    create_key_for_team_member,
    sender=TeamMember,
    dispatch_uid="create_key_for_team_member",
    weak=False,
)
pre_delete.connect(
    remove_key_for_team_member,
    sender=TeamMember,
    dispatch_uid="remove_key_for_team_member",
    weak=False,
)
user_logged_in.connect(set_language_on_logon)

add_introspection_rules([], ["^social_auth\.fields\.JSONField"])
示例#30
0
    if (user is not None) and (device is not None) and (device.user_id
                                                        == user.pk):
        request.session[DEVICE_ID_SESSION_KEY] = device.persistent_id
        request.user.otp_device = device


def _handle_auth_login(sender, request, user, **kwargs):
    """
    Automatically persists an OTP device that was set by an OTP-aware
    AuthenticationForm.
    """
    if hasattr(user, 'otp_device'):
        login(request, user.otp_device)


user_logged_in.connect(_handle_auth_login)


def verify_token(user, device_id, token):
    """
    Attempts to verify a :term:`token` against a specific device, identified by
    :attr:`~django_otp.models.Device.persistent_id`.

    This wraps the verification process in a transaction to ensure that things
    like throttling polices are properly enforced.

    :param user: The user supplying the token.
    :type user: :class:`~django.contrib.auth.models.User`

    :param str device_id: A device's persistent_id value.
示例#31
0
    class Meta:
        verbose_name = 'IpAddress'
        verbose_name_plural = 'IpAddresses'


##SAVE IP-ADDRESS FOR SIGN IN USER
def save_login_user_ip_address(sender, user, request, **kwargs):
    try:
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ipaddress = x_forwarded_for.split(',')[-1].strip()
        else:
            ipaddress = request.META.get('REMOTE_ADDR')

        if ipaddress:
            activity_name = 'Sign-in'
            customer_user = Customer.objects.get(user=user)
            ip_add = IpAddress()
            ip_add.customer = customer_user
            ip_add.ip_address = ipaddress
            ip_add.comments = "saved sign-in user %s IP-Address" % user.username
            ip_add.activity = activity_name
            ip_add.save()

    except:
        pass


user_logged_in.connect(save_login_user_ip_address)
示例#32
0
from django.contrib.auth.signals import user_logged_in

def test(sender, user, request, **kwargs):
	print 'in test'
	request.session['test'] = 'Tested OK'

print 'outsde test'
user_logged_in.connect(test)
示例#33
0
        login(request, user)
        return redirect('dashboard')
    else:
        return render(request, 'account_activation_invalid.html')


log = logging.getLogger(__name__)


@receiver(user_logged_in)
def user_logged_in_callback(sender, request, user, **kwargs):
    ip = request.META.get('REMOTE_ADDR')
    log.info('login user: {user} via ip: {ip}'.format(user=user, ip=ip))


user_logged_in.connect(user_logged_in_callback)


@receiver(user_logged_out)
def user_logged_out_callback(sender, request, user, **kwargs):
    ip = request.META.get('REMOTE_ADDR')

    log.info('logout user: {user} via ip: {ip}'.format(user=user, ip=ip))


user_logged_out.connect(user_logged_out_callback)


@receiver(user_login_failed)
def user_login_failed_callback(sender, request, credentials, **kwargs):
    log.warning(
示例#34
0
        date=timezone.now().date())
    daily_ledger.login_count += 1
    daily_ledger.save()

    if profile.last_login.date() != timezone.now().date():
        daily_ledger.dau += 1
        daily_ledger.save()

    profile.last_login = timezone.now()
    profile.save()

    if profile.userkey == '0':
        profile.userkey_gen()


user_logged_in.connect(updateLastLogin)


def stats(request):
    '''
    This view extracts all the app data for viewing.
    '''

    context = dict()

    context['user_count'] = len(User.objects.all())
    context['todays_uploads_count'] = 0
    context['todays_file_count'] = 0
    context['todays_s_count'] = 0
    context['todays_u_count'] = 0
    context['dau'] = 0
示例#35
0
文件: models.py 项目: yephper/django
from django.db.models.manager import EmptyManager
from django.utils import six, timezone
from django.utils.encoding import python_2_unicode_compatible
from django.utils.translation import ugettext_lazy as _


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)


class PermissionManager(models.Manager):
    use_in_migrations = True

    def get_by_natural_key(self, codename, app_label, model):
        return self.get(
            codename=codename,
            content_type=ContentType.objects.db_manager(
                self.db).get_by_natural_key(app_label, model),
        )


@python_2_unicode_compatible
class Permission(models.Model):
示例#36
0
# after each loogin it will look for a match and create one
def login_user_mataches(sender, user, request, **kwargs):
    obj = Match.objects.filter(from_user=user)
    for abc in obj:
        if abc.to_user != user:
            if Match.objects.good_match(abc.to_user, user):
                add_to_list, created = MatchList.objects.get_or_create(user=user, match=abc.to_user)
    obj2 = Match.objects.filter(to_user=user)
    for abc in obj2:
        if abc.from_user != user:
            if Match.objects.good_match(abc.from_user, user):
                add_to_list, created = MatchList.objects.get_or_create(user=user, match=abc.from_user)
    request.session["new_matches_count"] = MatchList.objects.filter(user=user).filter(read=False).count()

user_logged_in.connect(login_user_mataches)


class MatchManager(models.Manager):
    # here the ordere for user it doesn't matter
    def are_matched(self, user1, user2):
        if self.filter(from_user=user1, to_user=user2).count()>0:
            obj = Match.objects.get(from_user=user1, to_user=user2)
            perc = obj.percent * 100
            return perc 
        if self.filter(from_user=user2, to_user=user1).count()>0:
            obj = Match.objects.get(from_user=user2, to_user=user1)
            perc = obj.percent * 100
            return perc
        else:
            return False
示例#37
0

def deprecated(message):
    """ Mark function as deprecated.

        >>> @deprecated("thenineties is deprecated")
        ... def thenineties():
        ...     print 'hi'

    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            warnings.warn(message, DeprecationWarning, stacklevel=2)
            return func(*args, **kwargs)

        return wrapper

    return decorator


def block_if_not_staff(sender, user, request, **kwargs):
    staff_only_login = BoolSetting.get('setting-staff-only-login').get_value()
    if staff_only_login and not user.is_staff:
        messages.error(request, _('Only staff members can log in'))
        logout(request)


if not 'test' in sys.argv:
    user_logged_in.connect(block_if_not_staff)
示例#38
0
logger = logging.getLogger(__name__)


def user_logged_in_handler(sender, request, user, **kwargs):
    """
    in authenticate method, the request is not available so, the session engine is either not available.
    By using this signal binding, we can get the special attributes added to the object by the authenticate
    method and save them in the current session
    """
    if 'dn' in user.__dict__ and user.dn is not None:
        request.session['LDAP_USER_DN'] = user.dn
    if 'bu' in user.__dict__ and user.bu is not None:
        request.session['LDAP_USER_BU'] = user.bu


user_logged_in.connect(user_logged_in_handler)


def create_password():
    # generate password
    chars = string.ascii_letters + string.digits + '!@#$%&*'
    random.seed = (os.urandom(1024))
    families = 0
    passwd = ''
    while families < 3:
        passwd = ''.join(random.choice(chars) for i in range(10))
        lowercase = [c for c in passwd if c.islower()]
        uppercase = [c for c in passwd if c.isupper()]
        digits = [c for c in passwd if c.isdigit()]
        ponctuation = [c for c in passwd if not c.isalnum()]
示例#39
0
    form_class = UserCreationForm
    success_url = reverse_lazy('login')
    template_name = 'registration/signup.html'

def makeNewMember(sender,user,request,**kwargs):
    messages.add_message(request,messages.INFO, "Successful login!")
    print("A user has logged in, checking if they have a member")
    q = Member.objects.filter(user=user)
    if len(q) > 0:
        print("profile exists")
    else:
        print("making a new member profile ")
        z = Member(user=user,permission=0)
        z.save()
    # yep
user_logged_in.connect(makeNewMember) # this checks if you have a member account every time a user logs in

def allo(user):
    z = Member.objects.filter(user=user)
    print(z)
    if int(z[0].permission) == 1:
        print("successful allo test")
        return True
    return False

@login_required
def me(request):
    m = Member.objects.filter(user=request.user)
    return render(request,"userPage.html",{"member":m[0]})

@login_required
示例#40
0
            url, params = apiclient.normalize_url(course_api)
            apiclient.update_params(params)
            course_obj = apiclient.load_data(url)
            course = Course.objects.get_new_or_updated(course_obj,
                                                       namespace=site)

        # add course membership for permissions
        user.courses.add(course)

        # Redirect to notresponded page after login
        oauth.redirect_url = reverse('feedback:notresponded-course',
                                     kwargs={'course_id': course.id})

        # List LTI params in debug log
        logger.debug("LTI login for user %s on course %s", user, course)
        for k, v in sorted(oauth.params):
            logger.debug("  \w param -- %s: %s", k, v)

    if request and user:
        # add courses to users session
        courses = list(user.courses.all())
        request.session[SITES_SESSION_KEY] = [
            course.namespace_id for course in courses
        ]
        request.session[COURSES_SESSION_KEY] = [
            course.id for course in courses
        ]


user_logged_in.connect(add_course_permissions)
示例#41
0
def update_profile_weight(sender=None, user=None, request=None, **kwargs):
    """
        # mugshot = 100
        # biography = 50
        # email = 25
    """
    # TODO: add the year of the last sign on to the weight
    weight = 0
    # mugshot
    if user.profile.mugshot:
        weight = weight + 100
    # biography
    if user.profile.profile_type == 'm':
        if user.profile.artist_profile.biography:
            weight = weight + 50
    elif user.profile.profile_type == 'v':
        if user.profile.venueProfile.biography:
            weight = weight + 50
    # email
    if user.email:
        weight = weight + 25
    user.profile.weight = weight
    user.profile.save()

user_logged_in.connect(update_profile_weight)

def update_profiles():
    """ update the weight of all profiles """
    for profile in Profile.objects.all():
        update_profile_weight(user=profile.user)
示例#42
0
    def is_staff(self):
        "Is the user a member of staff?"
        # Simplest possible answer: All admins are staff
        return self.is_admin


def user_logged_in_signal(sender, signal, request, user, **kwargs):
    request.session.set_expiry(28800)  #expire session in 8 hrs
    membership_obj, created = Membership.objects.get_or_create(user=user)
    if created:
        membership_obj.save()
    else:
        user.membership.update_status()


user_logged_in.connect(user_logged_in_signal)


class UserProfile(models.Model):
    user = models.OneToOneField(MyUser)
    bio = models.TextField(null=True, blank=True)
    timestamp = models.DateTimeField(auto_now=False, auto_now_add=True)
    updated = models.DateTimeField(auto_now=True, auto_now_add=False)

    facebook = models.CharField(max_length=320,
                                null=True,
                                blank=True,
                                verbose_name='Facebook profile URL')
    twitter = models.CharField(max_length=320,
                               null=True,
                               blank=True,
示例#43
0
        cart = None
        try:
            old_cart = Cart.objects.get(user=user)
            new_cart = Cart.objects.get(id=cart_id)
            # We check if there was an old cart.
            # If there is, we iterate through the items in the cart to know if the user has added a clone of an old item in the new cart
            if old_cart:
                for item in new_cart.items.all():
                    if old_cart.items.all(
                    ).filter(item__slug=item.item.slug).exists(
                    ):  # If the item exists, we delete that item from the new cart else we add it to the old cart.
                        item.delete()
                    else:
                        item.user_id = user.id
                        item.save()
                        old_cart.items.add(item)
                cart = old_cart
                new_cart.delete(
                )  # we delete the cart that was created with session after adding new items to user's cart
            else:
                new_cart.user_id = user.id
                new_cart.save()
                cart = new_cart
        except Cart.DoesNotExist:
            cart = Cart.objects.get(id=cart_id)
        cart.user_id = user.id
        cart.save()


user_logged_in.connect(attach_cart)
示例#44
0
文件: core.py 项目: KinKir/sentry
# Anything that relies on default objects that may not exist with default
# fields should be wrapped in handle_db_failure
post_syncdb.connect(
    handle_db_failure(create_default_projects),
    dispatch_uid="create_default_project",
    weak=False,
)
post_save.connect(
    handle_db_failure(create_keys_for_project),
    sender=Project,
    dispatch_uid="create_keys_for_project",
    weak=False,
)
post_save.connect(
    handle_db_failure(create_org_member_for_owner),
    sender=Organization,
    dispatch_uid="create_org_member_for_owner",
    weak=False,
)
user_logged_in.connect(
    set_language_on_logon,
    dispatch_uid="set_language_on_logon",
    weak=False
)
post_save.connect(
    on_alert_creation,
    sender=Alert,
    dispatch_uid="on_alert_creation",
    weak=False,
)
示例#45
0
        if maintenance_response:
            return maintenance_response

    def _get_maintenance_response(self, request, view_func):
        if settings.DEBUG:
            # Allow media and static accesses in debug mode
            if request.path.startswith("/media") or request.path.startswith(
                    "/static"):
                return None
        if getattr(view_func, "maintenance_mode_exempt", False):
            return None
        if "login" in view_func.__name__:
            return None
        resolver_match = getattr(request, "resolver_match", None)
        if resolver_match and resolver_match.app_name == "shuup_admin":
            return None

        if request.shop.maintenance_mode and not is_admin_user(request):
            return HttpResponse(loader.render_to_string(
                "shuup/front/maintenance.jinja", request=request),
                                status=503)


if ("django.contrib.auth" in settings.INSTALLED_APPS
        and "shuup.front.middleware.ShuupFrontMiddleware"
        in settings.MIDDLEWARE_CLASSES):
    user_logged_in.connect(ShuupFrontMiddleware.refresh_on_user_change,
                           dispatch_uid="shuup_front_refresh_on_login")
    user_logged_out.connect(ShuupFrontMiddleware.refresh_on_logout,
                            dispatch_uid="shuup_front_refresh_on_logout")
示例#46
0
文件: models.py 项目: wozozo/hh
__all__ = (
    'AbstractBaseUser',
    'BaseUser',
    'AbstractAnonymousUser',
    'AnonymousUser',
)

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()
user_logged_in.connect(update_last_login)


class UserManager(models.Manager):
    def create_user(self, username, email=None, password=None):
        """
        Creates and saves a User with the given username, email and password.
        """
        now = timezone.now()

        # Normalize the address by lowercasing the domain part of the email
        # address.
        email = email or ''
        try:
            email_name, domain_part = email.strip().split('@', 1)
        except ValueError:
示例#47
0
    event.description = description
    event.user = request.user.username
    event.event_type = event_type
    event.save()


def set_status_online(sender, user, request, **kwargs):
    new_event(description='User logging in',
              request=request,
              event_type='access')


def redirect(request):
    if request.method == 'GET':
        url_to_redirect = request.GET['next_url']
        print(url_to_redirect)
        new_event('Redirecting to %s' % url_to_redirect, request, 'redirect')
        return HttpResponseRedirect(url_to_redirect)


@login_required()
@permission_required('is_superuser')
def events(request):
    event_objects = models.Event.objects.all().order_by('-timestamp')
    return render(request,
                  "app_160/events.html",
                  context={"events": event_objects})


user_logged_in.connect(set_status_online)
示例#48
0
    LANGUAGE_SESSION_KEY,
    check_for_language,
    get_language,
    to_locale,
)


def set_language_session(sender, user, **kwargs):
    """
    A signal receiver which updates the last_login date for
    the user logging in.
    """
    kwargs['request'].session['_language'] = user.lang_code


user_logged_in.connect(set_language_session)


@login_required
def set_lang(request):
    next = request.META.get('HTTP_REFERER', None)
    if not next:
        next = '/'
    response = HttpResponseRedirect(next)
    lang_code = request.POST.get('language_code', None)
    if not lang_code:
        lang_code = request.LANGUAGE_CODE
    if not lang_code or lang_code not in ('en', 'zh-cn'):
        lang_code = settings.LANGUAGE_CODE
    if lang_code and check_for_language(lang_code):
        if hasattr(request, 'session'):
示例#49
0
  if len(UserProfile.objects.filter(user=user)) == 0:
    UserProfile.objects.create(user=user, bio='')

class SongComment(models.Model):
  song     = models.ForeignKey(Song)
  author   = models.ForeignKey(User)
  created  = models.DateTimeField(auto_now_add=True)
  modified = models.DateTimeField(auto_now=True)
  text     = models.TextField()
  markdown = MarkdownField(text)

  history  = HistoricalRecords()

  def __unicode__(self):
    return self.author.username + " - " + self.song.name

  class Meta:
    ordering = ['-created']

from django.contrib.auth.signals import user_logged_in, user_logged_out

def logged_in(sender, user, request, **kwargs):
  logger.info('User %d (%s) logged in' % (user.id, user.username))

def logged_out(sender, user, request, **kwargs):
  if user is not None:
    logger.info('User %d (%s) logged out' % (user.id, user.username))

user_logged_in.connect(logged_in)
user_logged_out.connect(logged_out)
示例#50
0
    extra_context = {'logged_out': True}
    template_name = "nt_training/index.html"


# Already have login_required inherently
class NTUserEdit(auth_views.PasswordChangeView):
    template_name = "nt_training/user-edit.html"

    def get_success_url(self):
        return reverse_lazy('nt_training:ntUserEditDone')


class NTUserEditDone(auth_views.PasswordChangeDoneView):
    template_name = "nt_training/user-edit-done.html"


# Flash Messages


def logged_in_message(sender, user, request, **kwargs):
    # Add a welcome message when the user logs in
    messages.success(request, "Login successful!")


def logged_out_message(sender, user, request, **kwargs):
    # Add a welcome message when the user logs in
    messages.info(request, "You have logged out.")


user_logged_in.connect(logged_in_message)
user_logged_out.connect(logged_out_message)
示例#51
0
文件: auth.py 项目: ForkRepo/sentry
    )
    if language and hasattr(request, 'session'):
        request.session['django_language'] = language


def safe_update_last_login(sender, user, **kwargs):
    """
    Identical to Django's built-in handler except that we gracefully
    handle database failures.

    tl;dr logging in should not fail when a db is read-only
    """
    try:
        update_last_login(sender, user, **kwargs)
    except DatabaseError as exc:
        logging.warn(six.text_type(exc), exc_info=True)


user_logged_in.disconnect(update_last_login)
user_logged_in.connect(
    safe_update_last_login,
    dispatch_uid="safe_update_last_login",
    weak=False,
)

user_logged_in.connect(
    set_language_on_logon,
    dispatch_uid="set_language_on_logon",
    weak=False
)
示例#52
0

# -----------------------------------------------------------------------------
# Signal handlers
# -----------------------------------------------------------------------------

# Connected to user_logged_in
def create_session(sender, request, user, **kwargs):
    Session.objects.create_session(request, user)


# Connected to user_logged_out
def deactivate_session(sender, request, user, **kwargs):
    try:
        key = request.session.session_key
        instance = Session.objects.get(user=user, session_key=key)
        instance.active = False
        instance.save()
    except Session.DoesNotExist:
        pass


# Connected to post_delete for Session model
def post_delete_session(sender, instance, **kwargs):
    instance.delete_store_session()


user_logged_in.connect(create_session)
user_logged_out.connect(deactivate_session)
post_delete.connect(post_delete_session, sender=Session)
示例#53
0
def post_event(event_cls, request, user):
    payload = make_event_payload(user)
    if not payload:
        return
    metadata = EventMetadata(event_cls.event_type,
                             request=make_event_metadata_request(request),
                             tags=event_cls.tags)
    event = event_cls(metadata, payload)
    event.post()


def user_logged_in_callback(sender, request, user, **kwargs):
    post_event(LoginEvent, request, user)


user_logged_in.connect(user_logged_in_callback)


def user_logged_out_callback(sender, request, user, **kwargs):
    post_event(LogoutEvent, request, user)


user_logged_out.connect(user_logged_out_callback)


def user_login_failed_callback(sender, credentials, **kwargs):
    request = kwargs.get("request")  # introduced in django 1.11
    if request:
        request = make_event_metadata_request(request)
    metadata = EventMetadata(FailedLoginEvent.event_type,
                             request=request,
示例#54
0
# Signal Observe
#
def logged_in_handle(sender, user, request, **kwargs):
    #
    # Check if TU login
    prov = user.social_auth.filter(provider='tu')
    if prov.exists():
        data = prov[0].extra_data
        headers = {"Authorization": "Bearer {}".format(data['access_token'])}
        res = requests.get('https://api.tu.ac.th/api/me/',
                           headers=headers).json()

        refs = RefereeMapping.objects.filter(natid=res['description'])
        if refs.exists():
            ref = refs[0]
            ref.user = user
            ref.save()

        is_sci = False
        if res['company'] == 'คณะวิทยาศาสตร์และเทคโนโลยี':
            is_sci = True
        elif res['username'].isdigit() and res['username'][2:4] == '09':
            is_sci = True
        user.is_sci_member = is_sci
        if res['role']:
            user.role = res['role']
        user.save()


user_logged_in.connect(logged_in_handle)
示例#55
0
                user_referrer = User.objects.get(id=request.session.get('ur'))
            except:
                user_referrer = None
            del request.session['ur']

        source_referrer = request.session.get('sr')
        if source_referrer:
            del request.session['sr']

        profile = Profile(user=user,)
        if user_referrer:
            profile.user_referrer = user_referrer
        if source_referrer:
            profile.source_referrer = source_referrer
        profile.save()

    if not profile.hex_digi:
        m = hashlib.md5(datetime.datetime.utcnow().isoformat() + profile.user.username)
        profile.hex_digi = m.hexdigest()
        profile.save()

    if not profile.social_data_completed:
        profile.social_data_process()

    if not profile.email_opt_in_sent and user.email:
        profile.send_opt_in_email()
        profile.email_opt_in_sent = True
        profile.save()

user_logged_in.connect(user_signed_in)
示例#56
0
    try:
        cont_objs = Container.objects.filter(user__exact=user)

        if len(cont_objs) == 0:
            print('No containers assigned to user.')

        for cont in cont_objs:
            removeContainer(cont)
            
        scaleAllChallenges()

    except:
        print('Container does not exist for user.')
        # if none exists, log out
        
user_logged_in.connect(perform_some_action_on_login)
user_logged_out.connect(perform_some_action_on_logout)


class Me(DjangoObjectType):
    class Meta:
        model = User
        # only_fields = ('id', 'username', 'is_superuser')
        # filter_fields = ('id', 'username', 'is_superuser')


class TeamType(DjangoObjectType):
    class Meta:
        model = Team

示例#57
0
        finally:
            request.user = current_user

    def process_view(self, request, view_func, *view_args, **view_kwargs):
        maintenance_response = self._get_maintenance_response(request, view_func)
        if maintenance_response:
            return maintenance_response

    def _get_maintenance_response(self, request, view_func):
        if settings.DEBUG:
            # Allow media and static accesses in debug mode
            if request.path.startswith("/media") or request.path.startswith("/static"):
                return None
        if getattr(view_func, "maintenance_mode_exempt", False):
            return None
        if "login" in view_func.__name__:
            return None
        resolver_match = getattr(request, "resolver_match", None)
        if resolver_match and resolver_match.app_name == "shoop_admin":
            return None

        if request.shop.maintenance_mode and not getattr(request.user, 'is_superuser', False):
            return HttpResponse(loader.render_to_string("shoop/front/maintenance.jinja", request=request), status=503)

if (
    "django.contrib.auth" in settings.INSTALLED_APPS and
    "shoop.front.middleware.ShoopFrontMiddleware" in settings.MIDDLEWARE_CLASSES
):
    user_logged_in.connect(ShoopFrontMiddleware.refresh_on_user_change, dispatch_uid="shoop_front_refresh_on_login")
    user_logged_out.connect(ShoopFrontMiddleware.refresh_on_logout, dispatch_uid="shoop_front_refresh_on_logout")
示例#58
0
文件: models.py 项目: xssworm/sentry
)
post_save.connect(
    create_team_member_for_owner,
    sender=Team,
    dispatch_uid="create_team_member_for_owner",
    weak=False,
)
post_save.connect(
    update_document,
    sender=Group,
    dispatch_uid="update_document",
    weak=False,
)
pre_delete.connect(
    remove_key_for_team_member,
    sender=TeamMember,
    dispatch_uid="remove_key_for_team_member",
    weak=False,
)
user_logged_in.connect(set_language_on_logon,
                       dispatch_uid="set_language_on_logon",
                       weak=False)
post_save.connect(
    on_alert_creation,
    sender=Alert,
    dispatch_uid="on_alert_creation",
    weak=False,
)

add_introspection_rules([], ["^social_auth\.fields\.JSONField"])
示例#59
0
        dataspaces = api.get_dataspace()
        dprojects = {}
        for d in dataspaces:
            if d['name'].startswith('nte_'):
                name=d['name'][4:]
                dprojects[name] = d
                try:
                    project, created=Project.objects.get_or_create(slug=name, 
                                                                   defaults={'name': name })
                    if created and not user.superuser_or_belongs_to(project):
                        logger.debug('Adding editor role in local project: %s', pname)
                        role = project.roles.get(role='Editor') # TODO get privileges from API
                        role.users.add(user)
                except:
                    logger.error("Unexpected error creating group '%s': %s", name, sys.exc_info()[0])
        logger.info('dataspace with nte projects: %s', dprojects)
        for p in user.get_authorized_projects():
            pname = cendari_clean_name(p.name)
            if pname not in dprojects:
                logger.debug('creating remote project: %s', pname)
                try:
                    api.create_dataspace('nte_'+pname,title=p.name)
                except CendariDataAPIException as e:
                    logger.error('Problem creating project "%s" with DATA Api: %s', pname, e)
    except CendariDataAPIException as e:
        logger.error('Problem synchonizing projects with DATA Api: %s', e)
    except:
        logger.error("Unexpected error: %s", exc_info()[0])

user_logged_in.connect(login_user_synchronize)
示例#60
0
                    'email': self.email,
                    'inviter': self,
                }

                email_template = 'pinax/notifications/account_active/account_active'
                adapter = get_invitations_adapter()
                adapter.send_invitation_email(email_template, self.email, ctx)
            except Exception:
                import traceback
                traceback.print_exc()

    def send_mail(self, template_prefix, context):
        if self.email:
            get_adapter().send_mail(template_prefix, self.email, context)


def get_anonymous_user_instance(user_model):
    return user_model(pk=-1, username='******')


""" Connect relevant signals to their corresponding handlers. """
user_logged_in.connect(do_login)
user_logged_out.connect(do_logout)
social_account_added.connect(update_user_email_addresses,
                             dispatch_uid=str(uuid4()),
                             weak=False)
user_signed_up.connect(notify_admins_new_signup,
                       dispatch_uid=str(uuid4()),
                       weak=False)
signals.post_save.connect(profile_post_save, sender=settings.AUTH_USER_MODEL)