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)
