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
def ready(self): pre_save.connect(self.update_count_pre_save) pre_delete.connect(self.update_count_pre_save) post_save.connect(self.update_count_post_save) user_logged_out.connect(self.remove_auth_token) self.set_registration_active() self.clear_last_objects_cache()
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
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
def test_logout_with_user(self): """Logout should send user_logged_out signal if user was logged in.""" def listener(*args, **kwargs): listener.executed = True listener.executed = False user_logged_out.connect(listener) self.client.login(username='******', password='******') self.client.logout() user_logged_out.disconnect(listener) self.assertTrue(listener.executed)
def test_logout_without_user(self): """Logout should send signal even if user not authenticated.""" def listener(user, *args, **kwargs): listener.user = user listener.executed = True listener.executed = False user_logged_out.connect(listener) self.client.login(username='******', password='******') self.client.logout() user_logged_out.disconnect(listener) self.assertTrue(listener.executed) self.assertIsNone(listener.user)
def test_logout_doesnt(self): """ Admin 'logout' view just redirects to home. The default version exposes us to logout CSRF. We remove the admin logout link to, but we still need to neuter the actual view since removing it from the url patterns is a pain. """ from django.contrib.auth.signals import user_logged_out def handler(*args, **kwargs): self.fail("User logged out, should not have been.") user_logged_out.connect(handler, weak=True) user = self.F.UserFactory.create(is_staff=True) res = self.app.get(reverse("admin:logout"), user=user) self.assertRedirects(res, "/")
def test_logout(self): # Stuff for testing if the user logged out self.login() from django.contrib.auth.signals import user_logged_out u = User.objects.get(pk=1) u.passed = False def logged_out(sender, user, **kwargs): if user.id == u.id: u.passed = True user_logged_out.connect(logged_out) # The test procedure driver = self.driver driver.get(self.base_url + "/") driver.find_element_by_link_text("Log out").click() time.sleep(2) # Check the results self.assertTrue(u.passed, "The user should be logged out after we finish the logout test!")
def ready(self): from django.contrib.auth.models import update_last_login from django.contrib.auth.signals import user_logged_in, user_logged_out from watson import search as watson_search from inboxen import checks # noqa from inboxen import signals from inboxen.search import watson as search Inbox = self.get_model("Inbox") Email = self.get_model("Email") # Unregister update_last_login handler user_logged_in.disconnect(update_last_login) # Search watson_search.register(Email, search.EmailSearchAdapter) watson_search.register(Inbox, search.InboxSearchAdapter) user_logged_out.connect(signals.logout_message)
def ready(self): from django.contrib.auth.models import update_last_login from django.contrib.auth.signals import user_logged_in, user_logged_out from watson import search as watson_search from inboxen import checks, search, signals Inbox = self.get_model("Inbox") Email = self.get_model("Email") Request = self.get_model("Request") # Unregister update_last_login handler user_logged_in.disconnect(update_last_login) # Search watson_search.register(Email, search.EmailSearchAdapter) watson_search.register(Inbox, search.InboxSearchAdapter) pre_save.connect(signals.decided_checker, sender=Request, dispatch_uid="request_decided_checker") user_logged_out.connect(signals.logout_message)
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.')
if user.exists(): user = user.first() user.unsuccessful_login_attempts += 1 user.save() if user.unsuccessful_login_attempts > 10: ActivityStream(customer=user.customer, actor='unknown', verb='Login_fail_exceeded_10times_account_disabled', target=user.username).save() user.is_active = False user.save() user_logged_in.connect(login_do_stuff) user_logged_out.connect(logout_do_stuff) user_login_failed.connect(login_failed_do_stuff) class UserManager(BaseUserManager): def create_user(self, customer=None, username=None, email=None, password=None, first_name=None, last_name=None, phone=None, is_owner=False, is_team=False, is_client=False,
# catch django signals and emit ours def on_django_logged_in(sender, user, **kwargs): if not getattr(user, 'username', None): return logged_in.send(sender=Provider.__class__, provider=Provider.get_or_none(user.username, with_inactive=True)) user_logged_in.connect(on_django_logged_in) def on_django_logged_out(sender, user, **kwargs): if not getattr(user, 'username', None): return logged_out.send(sender=Provider.__class__, provider=Provider.get_or_none(user.username, with_inactive=True)) user_logged_out.connect(on_django_logged_out) # handle logged_in/out signals def on_logged_in(sender, provider, **kwargs): Action.record('logged_in', provider, Action.WEB) logged_in.connect(on_logged_in) def on_logged_out(sender, provider, **kwargs): Action.record('logged_out', provider, Action.WEB) logged_out.connect(on_logged_out)
setattr(AuditEvent, 'audit_command', AuditCommand.audit_command) def audit_login(sender, **kwargs): AuditEvent.audit_login(kwargs["request"], kwargs["user"], True) # success if user_logged_in: user_logged_in.connect(audit_login) def audit_logout(sender, **kwargs): AuditEvent.audit_logout(kwargs["request"], kwargs["user"]) if user_logged_out: user_logged_out.connect(audit_logout) def audit_login_failed(sender, **kwargs): AuditEvent.audit_login_failed(kwargs["request"], kwargs["username"]) user_login_failed.connect(audit_login_failed) class FieldAccess(models.Model): object_type = StringProperty() #String of ContentType, verbose_name='Case linking content type', blank=True, null=True) field = StringProperty() class Meta: app_label = 'auditcare' # class Meta:
class UserProfile(models.Model): user = models.OneToOneField(User) last_last_name = models.CharField(max_length=15, verbose_name=_('WLast name')) # avatar = models.ImageField(upload_to='images/users', verbose_name='Изображение') def __str__(self): return self.user class Meta: verbose_name = _('Profile') verbose_name_plural = _('Profiles') def do_stuff_in(sender, user, request, **kwargs): log_name = User.objects.get(username = user) logging.basicConfig(format = '%(levelname)-8s [%(asctime)s] %(message)s', level = logging.INFO, filename = 'logger1.log') logging.info('authorization by %s %s %s' %(log_name.last_name, log_name.first_name, log_name.userprofile.last_last_name)) def do_stuff_out(sender, user, request, **kwargs): log_name = User.objects.get(username = user) logging.basicConfig(format = '%(levelname)-8s [%(asctime)s] %(message)s', level = logging.INFO, filename = 'logger1.log') logging.info('logout by %s %s %s' %(log_name.last_name, log_name.first_name, log_name.userprofile.last_last_name)) user_logged_in.connect(do_stuff_in) user_logged_out.connect(do_stuff_out)
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 == "wshop_admin": return None if request.shop.maintenance_mode and not is_admin_user(request): return HttpResponse(loader.render_to_string( "wshop/front/maintenance.jinja", request=request), status=503) if ("django.contrib.auth" in settings.INSTALLED_APPS and "wshop.front.middleware.WshopFrontMiddleware" in settings.MIDDLEWARE_CLASSES): user_logged_in.connect(WshopFrontMiddleware.refresh_on_user_change, dispatch_uid="wshop_front_refresh_on_login") user_logged_out.connect(WshopFrontMiddleware.refresh_on_logout, dispatch_uid="wshop_front_refresh_on_logout")
if available_languages: translation.activate(available_languages[0]) else: # fallback to LANGUAGE_CODE translation.activate(settings.LANGUAGE_CODE) request.LANGUAGE_CODE = translation.get_language() 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 == "E-Commerce_admin": return None if request.shop.maintenance_mode and not is_admin_user(request): return HttpResponse(loader.render_to_string("E-Commerce/front/maintenance.jinja", request=request), status=503) if ( "django.contrib.auth" in settings.INSTALLED_APPS and "E-Commerce.front.middleware.E-CommerceFrontMiddleware" in settings.MIDDLEWARE_CLASSES ): user_logged_in.connect(E-CommerceFrontMiddleware.refresh_on_user_change, dispatch_uid="E-Commerce_front_refresh_on_login") user_logged_out.connect(E-CommerceFrontMiddleware.refresh_on_logout, dispatch_uid="E-Commerce_front_refresh_on_logout")
else: set_warning(message="User logged-in but doesn't have cookie set.", user_id=user.id) user_logged_in.connect(register_user_logged_in, dispatch_uid="USER_ANALYTICS_USER_LOGGED_IN") def register_user_logged_out(sender, request, user, **kwargs): """ A signal receiver which triggers USER_LOGGED_OUT """ if 'yb_user' in request.COOKIES: cookie = request.COOKIES['yb_user'] event_data = {'user_id': user.id} data = simplejson.dumps(event_data) register_event(tracking_id=cookie, event_name='USER_LOGGED_OUT', request=request, event_data=data) else: set_warning(message="User logged-out but doesn't have cookie set.", user_id=user.id) user_logged_out.connect(register_user_logged_out, dispatch_uid="USER_ANALYTICS_USER_LOGGED_OUT")
status = self.incident_comments.values('status__status_en').order_by( '-comment_created') if len(status) > 0: status = status[0] return status['status__status_en'] else: return '' def update_last_logout(sender, request, user, **kwargs): """ A signal receiver which updates the last_logout date for the user logging out. """ logout_timestamp = timezone.now() if 'lastRequest' in request.session: logout_timestamp = request.session['lastRequest'] del request.session['lastRequest'] logged_time = logout_timestamp - user.last_login ul = UserLog() ul.login = user.last_login ul.logout = logout_timestamp ul.total_seconds = logged_time.total_seconds() ul.user = user ul.save() user_logged_out.connect(update_last_logout)
emailjs_id = settings.EMAILJS_ID context = { "page": contact, "form": contact_form, "emailjs_id": emailjs_id, } return render(request, 'home/contact.html', context) """ credit: https://stackoverflow.com/questions/46542502/django- how-to-add-a-logout-successful-message-using-the-django-contrib-auth """ # show logout message when user logs out def show_logout_message(sender, user, request, **kwargs): if user_logged_out: messages.info(request, 'You have been logged out.') user_logged_out.connect(show_logout_message) # show login message when user logs in def show_login_message(sender, user, request, **kwargs): if user_logged_in: messages.info(request, 'You are logged in.') user_logged_in.connect(show_login_message)
email_idkey = models.CharField(max_length=250) email_from = models.CharField(max_length=100, blank=True, null=True) email_status = models.IntegerField(default=0) email_body = models.TextField(blank=True, null=True) email_subject = models.CharField(max_length=300, blank=True, null=True) email_date = models.CharField(max_length=50, blank=True, null=True) email_time = models.DateTimeField(auto_now_add=True) email_case = models.IntegerField(default=0) class Cases(models.Model): """model for Case Numbers to track case numbers""" case_number = models.IntegerField(default=0) case_source = models.CharField(max_length=20, editable=False) case_time = models.DateTimeField(auto_now_add=True) case_disposition = models.CharField(max_length=100, blank=True, null=True) def login_user(sender, request, user, **kwargs): user.HelplineUser.hl_status = 'Available' user.HelplineUser.save() def logout_user(sender, request, user, **kwargs): user.HelplineUser.hl_status = 'Unavailable' user.HelplineUser.save() user_logged_in.connect(login_user) user_logged_out.connect(logout_user)
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)
if '@blur' not in select: select['@blur'] = 'saveInput' self.fields = fields self.content = soup.prettify() print('args:', args, 'kwargs:', kwargs) logger.warning('{} | Form: "{}" updated/created'.format( timezone.now(), self.name)) super(Form, self).save(*args, **kwargs) @receiver(post_save, sender=settings.AUTH_USER_MODEL) def create_auth_token(sender, instance=None, created=False, **kwargs): if created: Token.objects.create(user=instance) def log_logins(sender, user, request, **kwargs): logger.warning('{} | User: "******" logged in'.format(timezone.now(), user.username)) def log_logouts(sender, user, request, **kwargs): logger.warning('{} | User: "******" logged out'.format(timezone.now(), user.username)) user_logged_in.connect(log_logins) user_logged_out.connect(log_logouts)
def set_status(sender, **kwagrs): if kwagrs['created']: user_profile = UserProfile.objects.create(user=kwagrs['instance']) def update_status_login(sender, user, request, **kwargs): UserProfile.objects.filter(user=user).update(status=True) def update_status_logout(sender, user, request, **kwargs): UserProfile.objects.filter(user=user).update(status=False) post_save.connect(set_status, sender=User) user_logged_in.connect(update_status_login, sender=User) user_logged_out.connect(update_status_logout, sender=User) # Message Model class Messages(models.Model): sender = models.ForeignKey(User, related_name="sender", on_delete=models.CASCADE) receiver = models.ForeignKey(User, related_name="receiver", on_delete=models.CASCADE) msg = models.TextField(max_length=1000) timestamp = models.DateTimeField(auto_now_add=True) class Meta:
def ready(self): from .models import audit_login, audit_logout user_logged_in.connect(audit_login) user_logged_out.connect(audit_logout) #user_login_failed.connect(audit_login_failed) FIXME install_trace_id_header()
last_logout = models.DateTimeField() total_hours = models.CharField(null=True, max_length=20) def __str__(self): return self.user.username def represent_total_time(self): totsec = int(self.total_hours) hours, remainder = divmod(totsec, 3600) minutes, seconds = divmod(remainder, 60) return '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds)) def record_logout_timestamp(sender, user, request, **kwargs): profile, created = UserProfile.objects.get_or_create( user=user, defaults={'last_logout': datetime.now()}) custom_format = '%Y-%m-%d %H:%M:%S' last_login = datetime.strftime(user.last_login, custom_format) current_time = datetime.strftime(datetime.now(), custom_format) total_time = datetime.strptime(current_time, custom_format) - datetime.strptime( last_login, custom_format) if not created: total_time = int(profile.total_hours) + int(total_time.total_seconds()) profile.total_hours = str(total_time) profile.save() user_logged_out.connect(record_logout_timestamp)
bio = models.CharField(_('Short bio'), max_length=280, blank=True, null=True) def __str__(self): return self.username def get_absolute_url(self): return reverse('users:detail', kwargs={'username': self.username}) def get_profile_name(self): if self.name: return self.name return self.username def broadcast_login(sender, user, request, **kwargs): # Handler to be fired up upon user login signal to notify all users. notification_handler(user, "global", Notification.LOGGED_IN) def broadcast_logout(sender, user, request, **kwargs): # Handler to be fired up upon user logout signal to notify all users. notification_handler(user, "global", Notification.LOGGED_OUT) user_logged_in.connect(broadcast_login) user_logged_out.connect(broadcast_logout)
from django.contrib.auth.signals import user_logged_in, user_logged_out from django.contrib import messages from password_reset.signals import user_recovers_password def loggedin(sender, user, request, **kwargs): messages.add_message(request, messages.SUCCESS, 'You have been logged in successfully') def loggedout(sender, user, request, **kwargs): messages.add_message(request, messages.SUCCESS, 'You have been logged out successfully') def recover(sender, user, request, **kwargs): messages.add_message(request, messages.SUCCESS, 'Password reset successful. Please sign in') user_logged_in.connect(loggedin) user_logged_out.connect(loggedout) user_recovers_password.connect(recover)
cook = "%s=%s" % (name, value) if not cookies: cookies = cook else: cookies = cookies + '; ' + cook if cookies: if 'JSESSIONID' in request.session and request.session['JSESSIONID']: cookies = cookies + '; JSESSIONID=' + \ request.session['JSESSIONID'] header_params['Cookie'] = cookies gs_request = urllib2.Request(url, data, header_params) try: urllib2.urlopen(gs_request) except BaseException: tb = traceback.format_exc() if tb: logger.debug(tb) if 'access_token' in request.session: del request.session['access_token'] request.session.modified = True user_logged_in.connect(do_login) user_logged_out.connect(do_logout)
# Save only completed log items to the UserLogSummary UserLogSummary.add_log_to_summary(instance) @receiver(post_save, sender=UserLog) def cull_records(sender, **kwargs): """ Listen in to see when videos become available. """ if settings.USER_LOG_MAX_RECORDS_PER_USER and kwargs["created"]: # Works for None, out of the box current_models = UserLog.objects.filter(user=kwargs["instance"].user, activity_type=kwargs["instance"].activity_type) if current_models.count() > settings.USER_LOG_MAX_RECORDS_PER_USER: # Unfortunately, could not do an aggregate delete when doing a # slice in query to_discard = current_models \ .order_by("start_datetime")[0:current_models.count() - settings.USER_LOG_MAX_RECORDS_PER_USER] UserLog.objects.filter(pk__in=to_discard).delete() def logout_endlog(sender, request, user, **kwargs): if "facility_user" in request.session: # Logout, ignore any errors. try: UserLog.end_user_activity(request.session["facility_user"], activity_type="login") except ValidationError as e: logging.error("Failed to end_user_activity upon logout: %s" % e) del request.session["facility_user"] # End a log whenever a logout event is fired. user_logged_out.connect(logout_endlog)
# Signal handlers ############################################################################################ def auth_log(message, user = None): if user == None: user = User.objects.get(pk = 1) entry = LogEntry(user = user, object_repr = message, action_flag = 4) entry.save() on_login = lambda **kwargs: auth_log(u'Вход в систему', kwargs['user']) on_logout = lambda **kwargs: auth_log(u'Выход из системы', kwargs['user']) on_login_error = lambda **kwargs: auth_log(u'Ошибка входа пользователя %s' % kwargs['credentials']['username']) user_logged_in.connect(on_login) user_logged_out.connect(on_logout) user_login_failed.connect(on_login_error) def construct_log_entry(**kwargs): instance = kwargs['instance'] content_type = ContentType.objects.get_for_model(instance) user = get_request().user log_entry = {} log_entry['user'] = user log_entry['object_repr'] = str(instance) log_entry['content_type'] = content_type log_entry['object_id'] = instance.id if hasattr(instance, 'id') else -1 return log_entry @receiver(post_save) def after_save(*args, **kwargs):
def save(self, *args, **kwargs): """ On save update the Effective_Date """ if not self.id: self.effective_date = datetime.today() return super(Agreement, self).save(*args, **kwargs) def alertme(sender, user, request, **kwargs): print("USER LOGGED OUT!") #or more sophisticated logging user_logged_out.connect(alertme) class ValidSMSCode(models.Model): user = models.ForeignKey(settings.AUTH_USER_MODEL) sms_code = models.CharField(max_length=4, blank=True) expires = models.DateTimeField(default=datetime.now) send_outcome = models.CharField(max_length=250, blank=True) def __str__(self): return '%s for user %s expires at %s' % (self.sms_code, self.user, self.expires) def save(self, **kwargs): up = self.user rand_code = random.randint(1000, 9999)
from django.contrib.auth.signals import user_logged_out from rest_framework.authentication import TokenAuthentication from surf.apps.users.models import SessionToken class SessionTokenAuthentication(TokenAuthentication): model = SessionToken def delete_api_auth_token(sender, user, request, **kwargs): try: if user is not None: user.auth_token.delete() except SessionToken.DoesNotExist: pass user_logged_out.connect(delete_api_auth_token)
def __str__(self): # __unicode__ on Python 2 # return "%s %s (%s)" % (self.first_name, # self.last_name, # self.email) return str(self.username) def Meta(self): verbose_name = _('User') verbose_name_plural = _('Users') def alertme(sender, user, request, **kwargs): print("USER LOGGED OUT!") # or more sophisticated logging user_logged_out.connect(alertme) class ValidSMSCode(models.Model): user = models.ForeignKey(settings.AUTH_USER_MODEL) sms_code = models.CharField(max_length=4, blank=True) expires = models.DateTimeField(default=datetime.now) send_outcome = models.CharField(max_length=250, blank=True) def __str__(self): return '%s for user %s expires at %s' % (self.sms_code, self.user, self.expires) def save(self, **kwargs): up = self.user
# Pykeg is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # Pykeg is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Pykeg. If not, see <http://www.gnu.org/licenses/>. from django.contrib.auth.signals import user_logged_in from django.contrib.auth.signals import user_logged_out from django.contrib import messages def on_logged_in(sender, user, request, **kwargs): messages.add_message(request, messages.INFO, 'You are now logged in!') user_logged_in.connect(on_logged_in) def on_logged_out(sender, user, request, **kwargs): messages.add_message(request, messages.INFO, 'You have been logged out.') user_logged_out.connect(on_logged_out)
get_invitations_adapter().send_mail( email_template, self.email, ctx) except Exception: import traceback traceback.print_exc() def get_anonymous_user_instance(Profile): return Profile(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=Profile )
# Cria o usuário padrão if User.objects(is_superuser=True).count() < 1: u = User(username="******", first_name="Administrador", email="*****@*****.**", editable=False, is_superuser=True) u.set_password('Lethus725') u.save() def user_logged_in_cb(sender, request, user, **kwargs): if user: user.register_historic(None, 'auth.login') def user_logged_out_cb(sender, request, user, **kwargs): if user: user.register_historic(None, 'auth.logout') user_logged_in.connect( user_logged_in_cb, dispatch_uid="supportcenter.accounts.models.user_logged_in_cb") user_logged_out.connect( user_logged_out_cb, dispatch_uid="supportcenter.accounts.models.user_logged_out_cb")
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 getattr( request.user, 'is_superuser', False): 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")
# TODO pass audit.save() setattr(AuditEvent, 'audit_command', AuditCommand.audit_command) def audit_login(sender, **kwargs): AuditEvent.audit_login(kwargs["request"], kwargs["user"], True) # success if user_logged_in: user_logged_in.connect(audit_login) def audit_logout(sender, **kwargs): AuditEvent.audit_logout(kwargs["request"], kwargs["user"]) if user_logged_out: user_logged_out.connect(audit_logout) def audit_login_failed(sender, **kwargs): AuditEvent.audit_login_failed(kwargs["request"], kwargs["username"]) user_login_failed.connect(audit_login_failed)
def ready(self): super(UserManagementApp, self).ready() from actstream import registry Group = apps.get_model(app_label='auth', model_name='Group') User = get_user_model() DynamicSerializerField.add_serializer( klass=get_user_model(), serializer_class= 'mayan.apps.user_management.serializers.UserSerializer') # Silence UnorderedObjectListWarning # "Pagination may yield inconsistent result" # TODO: Remove on Django 2.x Group._meta.ordering = ('name', ) Group._meta.verbose_name = _('Group') Group._meta.verbose_name_plural = _('Groups') Group._meta.get_field('name').verbose_name = _('Name') # Silence UnorderedObjectListWarning # "Pagination may yield inconsistent result" # TODO: Remove on Django 2.x User._meta.ordering = ('pk', ) User._meta.verbose_name = _('User') User._meta.verbose_name_plural = _('Users') User._meta.ordering = ('last_name', 'first_name') User._meta.get_field('username').verbose_name = _('Username') User._meta.get_field('first_name').verbose_name = _('First name') User._meta.get_field('last_name').verbose_name = _('Last name') User._meta.get_field('email').verbose_name = _('Email') User._meta.get_field('is_active').verbose_name = _('Is active?') if six.PY3: User.has_usable_password.short_description = _( 'Has usable password?') else: User.has_usable_password.__func__.short_description = _( 'Has usable password?') Group.add_to_class(name='get_users', value=method_group_get_users) Group.add_to_class(name='users_add', value=method_group_users_add) Group.add_to_class(name='users_remove', value=method_group_users_remove) Group.add_to_class(name='save', value=get_method_group_save()) MetadataLookup(description=_('All the groups.'), name='groups', value=get_groups) MetadataLookup(description=_('All the users.'), name='users', value=get_users) ModelEventType.register(event_types=(event_group_created, event_group_edited), model=Group) ModelEventType.register(event_types=(event_user_created, event_user_edited), model=User) ModelPermission.register(model=Group, permissions=( permission_acl_edit, permission_acl_view, permission_events_view, permission_group_delete, permission_group_edit, permission_group_view, )) ModelPermission.register( model=User, permissions=(permission_acl_edit, permission_acl_view, permission_events_view, permission_user_delete, permission_user_edit, permission_user_view)) SourceColumn(attribute='name', is_identifier=True, is_sortable=True, source=Group) SourceColumn(attribute='user_set.count', label=_('Users'), source=Group) SourceColumn(attribute='username', is_object_absolute_url=True, is_identifier=True, is_sortable=True, source=User) SourceColumn(attribute='first_name', is_sortable=True, source=User) SourceColumn(attribute='last_name', is_sortable=True, source=User) SourceColumn(attribute='email', is_sortable=True, source=User) SourceColumn(attribute='is_active', is_sortable=True, source=User, widget=TwoStateWidget) SourceColumn(attribute='has_usable_password', source=User, widget=TwoStateWidget) User.add_to_class(name='get_absolute_url', value=method_user_get_absolute_url) User.add_to_class(name='get_groups', value=method_user_get_groups) User.add_to_class(name='groups_add', value=method_user_groups_add) User.add_to_class(name='groups_remove', value=method_user_groups_remove) User.add_to_class(name='save', value=get_method_user_save()) dashboard_main.add_widget(widget=DashboardWidgetUserTotal, order=99) dashboard_main.add_widget(widget=DashboardWidgetGroupTotal, order=99) menu_list_facet.bind_links(links=( link_acl_list, link_events_for_object, link_object_event_types_user_subcriptions_list, link_group_user_list, ), sources=(Group, )) menu_list_facet.bind_links( links=(link_acl_list, link_events_for_object, link_object_event_types_user_subcriptions_list, link_user_group_list, link_user_set_options), sources=(User, )) menu_multi_item.bind_links(links=(link_user_multiple_delete, ), sources=('user_management:user_list', )) menu_object.bind_links(links=(link_group_edit, ), sources=(Group, )) menu_object.bind_links(links=(link_group_delete, ), position=99, sources=(Group, )) menu_object.bind_links(links=( link_user_delete, link_user_edit, ), sources=(User, )) menu_secondary.bind_links( links=(link_group_list, link_group_create), sources=('user_management:group_multiple_delete', 'user_management:group_list', 'user_management:group_create', Group)) menu_secondary.bind_links( links=(link_user_list, link_user_create), sources=(User, 'authentication:user_multiple_set_password', 'user_management:user_multiple_delete', 'user_management:user_list', 'user_management:user_create')) menu_setup.bind_links(links=(link_user_setup, link_group_setup)) menu_user.bind_links(links=( text_user_label, separator_user_label, link_current_user_details, link_current_user_edit, ), position=0) post_save.connect( dispatch_uid='user_management_handler_initialize_new_user_options', receiver=handler_initialize_new_user_options, sender=User) user_logged_in.connect( dispatch_uid='user_management_handler_user_logged_in', receiver=handler_user_logged_in, sender=User) user_logged_out.connect( dispatch_uid='user_management_handler_user_logged_out', receiver=handler_user_logged_out, sender=User) registry.register(Group) registry.register(User)
template_name = "ts_training/index.html" # Already have login_required inherently class NTUserEdit(auth_views.PasswordChangeView): template_name = "ts_training/user-edit.html" def get_success_url(self): return reverse_lazy('ts_training:UserEditDone') class NTUserEditDone(auth_views.PasswordChangeDoneView): template_name = "ts_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)
def create_edu_id_badge_instance(social_login): user = social_login.user super_user = BadgeUser.objects.get(username=settings.SUPERUSER_NAME) badge_class = BadgeClass.objects.get(name=settings.EDUID_BADGE_CLASS_NAME) # Issue first badge for user badge_class.issue(recipient=user, created_by=super_user, allow_uppercase=True, enforce_validated_name=False, recipient_type=BadgeInstance.RECIPIENT_TYPE_EDUID, expires_at=None, extensions=None) logger.info( f"Assertion created for {user.email} based on {badge_class.name}") from django.contrib.auth.signals import user_logged_out, user_logged_in def print_logout_message(sender, user, request, **kwargs): print('user logged out') def print_login_message(sender, user, request, **kwargs): print('user logged in') user_logged_out.connect(print_logout_message) user_logged_in.connect(print_login_message)
from django.conf import settings from django.core.exceptions import MiddlewareNotUsed from debug_toolbar.middleware import DebugToolbarMiddleware from django.contrib.auth.signals import user_logged_out def iam_logged_out_actions(sender, user, request, **kwargs): print("logging out: " + str(user)) user_logged_out.connect(iam_logged_out_actions) class ComplianceMiddleware: ''' Middleware to add security-related response headers. If the SECURITY_HEADERS_ON_ERROR_ONLY setting is True, then the headers will only be added to error responses (400 and above). This behavior is needed for cloud.gov deployments because its proxy adds the headers to 200 responses, but not to error responses. Otherwise, the headers will be added to all responses. We also want to ensure that /admin/ routes are never cached, so we'll add appropriate headers for those routes. ''' def process_response(self, request, response): if (not settings.SECURITY_HEADERS_ON_ERROR_ONLY or response.status_code >= 400):
password=request.POST.get('password')) if user is not None: auth.login(request, user) messages.error(request, "You have successfully logged in") return redirect(reverse('profile')) else: form.add_error(None, "Your email or password was not recognised") else: form = UserLoginForm() args = {'form': form} args.update(csrf(request)) return render(request, 'login.html', args) def update_previous_login(sender, user, **kwargs): user.previous_login = timezone.now() user.save(update_fields=['previous_login']) user_logged_out.connect(update_previous_login) def logout(request): auth.logout(request) messages.success(request, 'You have successfully logged out') return redirect(reverse('index'))
status = self.incident_comments.values( 'status__status_en').order_by('-comment_created') if len(status) > 0: status = status[0] return status['status__status_en'] else: return '' def update_last_logout(sender, request, user, **kwargs): """ A signal receiver which updates the last_logout date for the user logging out. """ logout_timestamp = timezone.now() if 'lastRequest' in request.session: logout_timestamp = request.session['lastRequest'] del request.session['lastRequest'] ul = UserLog( ) ul.login = user.last_login ul.logout = logout_timestamp try: logged_time = logout_timestamp - user.last_login ul.total_seconds = logged_time.total_seconds() except: pass #avoid #20 error for now: TypeError: unsupported operand type(s) for -: 'datetime.datetime' and 'NoneType' ul.user = user ul.save() user_logged_out.connect(update_last_logout)
self._geoip_data = None try: gip = GeoIP(cache=GEOIP_CACHE_TYPE) self._geoip_data = gip.city(self.ip_address) except GeoIPException: log.error('Error getting GeoIP data for IP "%s": %s' % (self.ip_address, traceback.format_exc())) return self._geoip_data class Meta(object): ordering = ('-start_time',) permissions = ( ('view_visitor', 'Can view visitor'), ) class Pageview(models.Model): visitor = models.ForeignKey(Visitor, related_name='pageviews') url = models.CharField(max_length=500) view_time = models.DateTimeField() objects = PageviewManager() class Meta(object): ordering = ('-view_time',) from tracking import handlers user_logged_out.connect(handlers.track_ended_session) post_save.connect(handlers.post_save_cache, sender=Visitor)
def connect_signal(self): user_logged_in.connect(authenticate_user) user_logged_out.connect(logout_user)
def sync_schedule_after_reminder_single_events_was_modified(sender, **kwargs): if kwargs['action'] == 'post_add': events = SingleEvent.future_events.filter(id__in=kwargs["pk_set"]) for reminder_type in REMINDER_TYPES: if kwargs['instance'].check_reminder_type_state(reminder_type): reminding_service.add_single_events_to_schedule(kwargs['instance'], events, reminder_type) if kwargs['action'] == 'post_remove': AccountReminding.objects.filter(single_event__id__in=kwargs["pk_set"]).delete() def sync_schedule_after_reminder_settings_was_changed(sender, instance, created, **kwargs): AccountReminding.objects.filter(account_id=instance.id).delete() for reminder_type in REMINDER_TYPES: if instance.check_reminder_type_state(reminder_type): reminding_service.add_single_events_to_schedule(instance, instance.reminder_single_events.all(), reminder_type) user_logged_in.connect(after_login) user_logged_out.connect(after_logout) post_save.connect(create_facebook_profile, sender=User) post_save.connect(after_account_save, sender=Account) post_save.connect(sync_schedule_after_reminder_settings_was_changed, sender=Account) m2m_changed.connect(sync_schedule_after_reminder_single_events_was_modified, sender=Account.reminder_single_events.through)
def _create_submission_folder(**kwargs): if not os.path.exists(MEDIA_ROOT+'submissions/'): os.makedirs(MEDIA_ROOT+'submissions/') def _clear_user_cache(user, **kwargs): cache.delete(user.username+'_l') cache.delete(user.username+'_s') post_save.connect(_create_profile, sender=User, dispatch_uid="unique_id") post_syncdb.connect(_create_public_group) post_syncdb.connect(_create_submission_folder) user_logged_out.connect(_clear_user_cache) def remove_obj_perms_connected_with_user(sender, instance, **kwargs): ''' Remove all permissions connected with the user to avoid orphan permissions ''' filters = Q(content_type=ContentType.objects.get_for_model(instance), object_pk=instance.pk) UserObjectPermission.objects.filter(filters).delete() GroupObjectPermission.objects.filter(filters).delete() pre_delete.connect(remove_obj_perms_connected_with_user, sender=User) class Submission(models.Model): ''' Model to represent a file submitted together with the bundle to be stored
user = session_grant.create_user() return user def clean_username(self, username): """ Performs any cleaning on the "username" prior to using it to get or create the user object. Returns the cleaned username. By default, returns the username unchanged. """ return username def configure_user(self, user): """ Configures a user after creation and returns the updated user. By default, returns the user unmodified. """ return user def get_user(self, user_id): return CacheUserProxy(user_id).get() def logged_out_signal(sender, request, user, **kwargs): if sender == OIDCUser.__class__: cup = CacheUserProxy(user.pk) cup.delete() user_logged_out.connect(logged_out_signal)
else: # TODO for now just set a dummy default - logged in user with no role assigned request.session['ACTIVE_ROLE'] = USER_ROLE # try to start agent if user.agent is not None: handle_agent_login_internal(request, user.agent) role = request.session['ACTIVE_ROLE'] request.session['ARIES_PROFILE'] = url_aries_profile(role) print("Profile =", request.session['ARIES_PROFILE']) # setup background "virtual agent" user_logged_in_handler(sender, user, request, **kwargs) def clear_user_session(sender, user, request, **kwargs): # setup background "virtual agent" user_logged_out_handler(sender, user, request, **kwargs) if 'ACTIVE_ROLE' in request.session: del request.session['ACTIVE_ROLE'] if 'ACTIVE_ORG' in request.session: del request.session['ACTIVE_ORG'] request.session['ARIES_PROFILE'] = '' user_logged_in.connect(init_user_session) user_logged_out.connect(clear_user_session)
except NeoProfile.DoesNotExist: pass # figure out something to do here def neo_login(sender, **kwargs): try: # check that neo profile exists - throws DoesNotExist if there is no profile neo_profile = kwargs['user'].neoprofile # Authenticate via Neo in addition to Django if neo_profile: api.authenticate(neo_profile.login_alias, neo_profile.password) except NeoProfile.DoesNotExist: pass user_logged_in.connect(neo_login) user_logged_out.connect(notify_logout) def stash_neo_fields(member, clear=False): stashed_fields = {} ''' Stash the neo fields that aren't required and clear them on the instance so that they aren't saved to db ''' for key in (NEO_ATTR.union(ADDRESS_FIELDS)).difference(JMBO_REQUIRED_FIELDS): stashed_fields[key] = getattr(member, key) ''' If field can be null, set to None. Otherwise assign a default value. If a default value has not been specified, assign the default of the python type '''
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, tags=FailedLoginEvent.tags) event = FailedLoginEvent(metadata, credentials) event.post() user_login_failed.connect(user_login_failed_callback)
# Log the event LogEvent.objects.create(type=LOG_EVENT_LOGIN_FAILED, username=credentials['username'], ip_address=None) user_login_failed.connect(_handle_user_login_failed) def _handle_user_logout(sender, request, user, **kwargs): """ Handle user logout. :param sender: The sender class. :param request: The current request. :param user: The logged-out user. :param kwargs: Extra keywords arguments. :return: None """ # Do nothing if the user was not logged-in if user is None: return # Log the event LogEvent.objects.create(type=LOG_EVENT_LOGOUT, username=user.username, ip_address=get_client_ip_address(request)) user_logged_out.connect(_handle_user_logout)
self._geoip_data = None try: gip = GeoIP(cache=GEOIP_CACHE_TYPE) self._geoip_data = gip.city(self.ip_address) except GeoIPException: log.error('Error getting GeoIP data for IP "%s": %s' % (self.ip_address, traceback.format_exc())) return self._geoip_data class Meta(object): ordering = ('-start_time', ) permissions = (('view_visitor', 'Can view visitor'), ) class Pageview(models.Model): visitor = models.ForeignKey(Visitor, related_name='pageviews') url = models.CharField(max_length=500) method = models.CharField(max_length=20, null=True) view_time = models.DateTimeField() objects = PageviewManager() class Meta(object): ordering = ('-view_time', ) from tracking import handlers user_logged_out.connect(handlers.track_ended_session) post_save.connect(handlers.post_save_cache, sender=Visitor)
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, tags=FailedLoginEvent.tags) event = FailedLoginEvent(metadata, credentials) event.post() user_login_failed.connect(user_login_failed_callback)
@classmethod def has_varname(cls, user, varname): """ Checks to see if a given varname has been logged for this user. """ logs = cls.objects.filter(user=user, varname=varname) return logs.exists() # Login/Logout signals from django.contrib.auth.signals import user_logged_in, user_logged_out def login_handler(sender, user, request, **kwargs): if not hasattr(request, 'user'): request.user = user Log.objects.create_log('progstar', request) Log.objects.create_log('VisitNo', request) Log.objects.create_log( 'IPAddr', request, request.META.get('REMOTE_ADDR', '')) Log.objects.create_log( 'UsrAgnt', request, request.META.get('HTTP_USER_AGENT', '')) user_logged_in.connect(login_handler) def logout_handler(sender, request, **kwargs): if request.user.is_authenticated(): Log.objects.create_log('progstop', request) user_logged_out.connect(logout_handler)
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")
return '%s@%s' % (self.session_id, self.created) def okay_auth(self, request, user): ''' Is the auth okay for this request/user? Hook here to allow apps to customize behaviour. Returns a boolean pair: Is standard Django auth okay? Is 2FA okay? May assume that Django auth *and* OTP auth have said yes. Only need to restrict further. ''' return check_auth(self, request, user) def logged_in_listener(request, **kwargs): SessionInfo.just_logged_in(request) def logged_out_listener(request, **kwargs): SessionInfo.just_logged_out(request) user_logged_in.connect(logged_in_listener) user_logged_out.connect(logged_out_listener) def session_create_listener(instance, **kwargs): instance.session_info = SessionInfo.for_session(instance) post_save.connect(session_create_listener, sender=Session)