haiwen/seahub
1
0
Fork 0
mirror of https://github.com/haiwen/seahub.git synced 2025-10-21 10:51:17 +00:00
Code Issues Releases Wiki Activity

send activity email when org register

Browse Source
This commit is contained in:
lian
2025-04-02 16:14:00 +08:00
parent 09581a961a
commit 04f948f7e4
3 changed files with 107 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
thirdpart/registration/models.py
View File

@@ -1,44 +1,52 @@
import datetime
import hashlib
import random
import re
import random
import hashlib
import logging
import datetime
from constance import config
from urllib.parse import quote
from django.conf import settings
from django.db import models
# from django.db import transaction
from django.urls import reverse
from django.dispatch import receiver
from django.template.loader import render_to_string
from django.utils.translation import gettext_lazy as _
from seahub.base.accounts import User
from seahub.utils import send_html_email
from seahub.profile.models import Profile
from seahub.utils import send_html_email, get_site_scheme_and_netloc
from registration.signals import user_registered
logger = logging.getLogger(__name__)
SHA1_RE = re.compile('^[a-f0-9]{40}$')
class RegistrationManager(models.Manager):
"""
Custom manager for the ``RegistrationProfile`` model.
The methods defined here provide shortcuts for account creation
and activation (including generation and emailing of activation
keys), and for cleaning out expired inactive accounts.
"""
def activate_user(self, activation_key):
"""
Validate an activation key and activate the corresponding
``User`` if valid.
If the key is valid and has not expired, return the ``User``
after activating.
If the key is not valid or has expired, return ``False``.
If the key is valid but the ``User`` is already active,
return ``False``.
To prevent reactivation of an account which has been
deactivated by site administrators, the activation key is
reset to the string constant ``RegistrationProfile.ACTIVATED``
@@ -75,41 +83,39 @@ class RegistrationManager(models.Manager):
By default, an activation email will be sent to the new
user. To disable this, pass ``send_email=False``.
"""
user = User.objects.create_user(username, password, False, is_active)
registration_profile = self.create_profile(user)
if send_email:
registration_profile.send_activation_email(site)
return user
def create_inactive_user(self, username, email, password,
site, send_email=True):
return self.create_email_user(username, email, password, site,
send_email, is_active=False)
# create_inactive_user = transaction.commit_on_success(create_inactive_user)
def create_active_user(self, username, email, password,
site, send_email=True):
return self.create_email_user(username, email, password, site,
send_email, is_active=True)
# create_inactive_user = transaction.commit_on_success(create_inactive_user)
def create_profile(self, user):
"""
Create a ``RegistrationProfile`` for a given
``User``, and return the ``RegistrationProfile``.
The activation key for the ``RegistrationProfile`` will be a
SHA1 hash, generated from a combination of the ``User``'s
username and a random salt.
"""
salt = hashlib.sha1(str(random.random()).encode('utf-8')).hexdigest()[:5].encode('utf-8')
username = user.username
@@ -118,49 +124,49 @@ class RegistrationManager(models.Manager):
# Take the first 16 character to avoid errors.
# (1406, "Data too long for column 'activation_key' at row 1")
activation_key = hashlib.sha256(salt+username).hexdigest()[:16]
activation_key = hashlib.sha256(salt+username).hexdigest()[:40]
return self.create(emailuser_id=user.id,
activation_key=activation_key)
def delete_expired_users(self):
"""
Remove expired instances of ``RegistrationProfile`` and their
associated ``User``s.
Accounts to be deleted are identified by searching for
instances of ``RegistrationProfile`` with expired activation
keys, and then checking to see if their associated ``User``
instances have the field ``is_active`` set to ``False``; any
``User`` who is both inactive and has an expired activation
key will be deleted.
It is recommended that this method be executed regularly as
part of your routine site maintenance; this application
provides a custom management command which will call this
method, accessible as ``manage.py cleanupregistration``.
Regularly clearing out accounts which have never been
activated serves two useful purposes:
1. It alleviates the ocasional need to reset a
``RegistrationProfile`` and/or re-send an activation email
when a user does not receive or does not act upon the
initial activation email; since the account will be
deleted, the user will be able to simply re-register and
receive a new activation key.
2. It prevents the possibility of a malicious user registering
one or more accounts and never activating them (thus
denying the use of those usernames to anyone else); since
those accounts will be deleted, the usernames will become
available for use again.
If you have a troublesome ``User`` and wish to disable their
account while keeping it in the database, simply delete the
associated ``RegistrationProfile``; an inactive ``User`` which
does not have an associated ``RegistrationProfile`` will not
be deleted.
"""
for profile in self.all():
if profile.activation_key_expired():
@@ -176,41 +182,41 @@ class RegistrationProfile(models.Model):
"""
A simple profile which stores an activation key for use during
user account registration.
Generally, you will not want to interact directly with instances
of this model; the provided manager includes methods
for creating and activating new accounts, as well as for cleaning
out accounts which have never been activated.
While it is possible to use this model as the value of the
``AUTH_PROFILE_MODULE`` setting, it's not recommended that you do
so. This model's sole purpose is to store data temporarily during
account registration and activation.
"""
ACTIVATED = "ALREADY_ACTIVATED"
# user = models.ForeignKey(User, unique=True, verbose_name=_('user'))
emailuser_id = models.IntegerField()
activation_key = models.CharField(_('activation key'), max_length=40)
objects = RegistrationManager()
class Meta:
verbose_name = _('registration profile')
verbose_name_plural = _('registration profiles')
def __unicode__(self):
return "Registration information for %s" % self.emailuser_id
def activation_key_expired(self):
"""
Determine whether this ``RegistrationProfile``'s activation
key has expired, returning a boolean -- ``True`` if the key
has expired.
Key expiration is determined by a two-step process:
1. If the user has already activated, the key will have been
reset to the string constant ``ACTIVATED``. Re-activating
is not permitted, and so this method returns ``True`` in
@@ -223,7 +229,7 @@ class RegistrationProfile(models.Model):
activate their account); if the result is less than or
equal to the current date, the key has expired and this
method returns ``True``.
"""
expiration_date = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)
@@ -232,8 +238,11 @@ class RegistrationProfile(models.Model):
except User.DoesNotExist:
return False
return self.activation_key == self.ACTIVATED or \
(datetime.datetime.fromtimestamp(user.ctime/1000000) + expiration_date <= datetime.datetime.now())
return (
self.activation_key == self.ACTIVATED
or (datetime.datetime.fromtimestamp(user.ctime/1000000) + expiration_date
<= datetime.datetime.now())
)
activation_key_expired.boolean = True
@@ -241,7 +250,7 @@ class RegistrationProfile(models.Model):
"""
Send an activation email to the user associated with this
``RegistrationProfile``.
The activation email will make use of two templates:
``registration/activation_email_subject.txt``
@@ -275,10 +284,10 @@ class RegistrationProfile(models.Model):
framework for details regarding these objects' interfaces.
"""
ctx_dict = { 'activation_key': self.activation_key,
'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,
'site': site,
'SITE_ROOT': settings.SITE_ROOT }
ctx_dict = {'activation_key': self.activation_key,
'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,
'site': site,
'SITE_ROOT': settings.SITE_ROOT}
subject = render_to_string('registration/activation_email_subject.txt',
ctx_dict)
# Email subject *must not* contain newlines
@@ -297,21 +306,7 @@ class RegistrationProfile(models.Model):
pass
########## signal handlers
import logging
from django.urls import reverse
from django.dispatch import receiver
from urllib.parse import quote
from registration.signals import user_registered
from seahub.utils import get_site_scheme_and_netloc
from constance import config
# Get an instance of a logger
logger = logging.getLogger(__name__)
# signal handlers
def notify_admins_on_activate_request(reg_email):
ctx_dict = {
"site_name": settings.SITE_NAME,
@@ -335,6 +330,7 @@ def notify_admins_on_activate_request(reg_email):
except Exception as e:
logger.error(e)
def notify_admins_on_register_complete(reg_email):
ctx_dict = {
"site_name": settings.SITE_NAME,
@@ -359,6 +355,7 @@ def notify_admins_on_register_complete(reg_email):
except Exception as e:
logger.error(e)
@receiver(user_registered)
def email_admin_on_registration(sender, **kwargs):
"""Send an email notification to admin when a newly registered user need