X-Git-Url: http://git.onelab.eu/?p=myslice.git;a=blobdiff_plain;f=portal%2Fmodels.py;h=65c97bc4d82fa0d7d543db0ec48b9ec9e9faf242;hp=06cfa547aa9be29d1fb11b432099eaa564dc991f;hb=0d118a5f600b06616c2841e92642a303d8785269;hpb=c550d62c7e6ef27635b31a8217819e0a966932a8 diff --git a/portal/models.py b/portal/models.py index 06cfa547..65c97bc4 100644 --- a/portal/models.py +++ b/portal/models.py @@ -53,265 +53,43 @@ class Institution(models.Model): name = models.TextField() # list of associated email domains -# code borrowed from django-registration -# https://bitbucket.org/ubernostrum/django-registration/ - -#DEPRECATED -#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`` -# after successful activation. -# -# """ -# # Make sure the key we're trying conforms to the pattern of a -# # SHA1 hash; if it doesn't, no point trying to look it up in -# # the database. -# if SHA1_RE.search(activation_key): -# try: -# profile = self.get(activation_key=activation_key) -# except self.model.DoesNotExist: -# return False -# if not profile.activation_key_expired(): -# user = profile.user -# user.is_active = True -# user.save() -# profile.activation_key = self.model.ACTIVATED -# profile.save() -# return user -# return False -# -# def create_user(self, first_name, last_name, email, password): -# pending_user = self.create(first_name=first_name, last_name=last_name, email=email, password=password) -# return pending_user -# -# def create_inactive_user(self, first_name, last_name, email, password, site, -# send_email=True): -# """ -# Create a new, inactive ``User``, generate a -# ``RegistrationProfile`` and email its activation key to the -# ``User``, returning the new ``User``. -# -# By default, an activation email will be sent to the new -# user. To disable this, pass ``send_email=False``. -# -# """ -# salt = hashlib.sha1(str(random.random())).hexdigest()[:5] -# if isinstance(email, unicode): -# email = email.encode('utf-8') -# activation_key = hashlib.sha1(salt+email).hexdigest() -# -# new_user = PendingUser.objects.create_user(first_name, last_name, email, password) -# new_user.is_active = False -# new_user.activation_key=activation_key -# new_user.save() -# -# # We might not need this -# #registration_profile = self.create_profile(new_user) -# -# if send_email: -# new_user.send_activation_email(site) -# #registration_profile.send_activation_email(site) -# -# return new_user -# 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())).hexdigest()[:5] -# username = user.username -# if isinstance(username, unicode): -# username = username.encode('utf-8') -# activation_key = hashlib.sha1(salt+username).hexdigest() -# return self.create(user=user, -# 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(): -# try: -# if profile.activation_key_expired(): -# user = profile.user -# if not user.is_active: -# user.delete() -# profile.delete() -# except User.DoesNotExist: -# profile.delete() -#DEPRECATED - class PendingUser(models.Model): # NOTE We might consider migrating the fields to CharField, which would # simplify form creation in forms.py - first_name = models.TextField() - last_name = models.TextField() -# affiliation = models.TextField() - email = models.EmailField() #validators=[validate_email]) - password = models.TextField() - keypair = models.TextField() - # institution + first_name = models.TextField() + last_name = models.TextField() + email = models.EmailField() #validators=[validate_email]) + password = models.TextField() + keypair = models.TextField() authority_hrn = models.TextField() + login = models.TextField() + pi = models.TextField() + created = models.DateTimeField(auto_now_add = True) # models.ForeignKey(Institution) -#DEPRECATED -# objects = RegistrationManager() -# -# class Meta: -# verbose_name = _('registration profile') -# verbose_name_plural = _('registration profiles') -# -# def __unicode__(self): -# return u"Registration information for %s" % self.email -# -# 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 -# this case. -# -# 2. Otherwise, the date the user signed up is incremented by -# the number of days specified in the setting -# ``ACCOUNT_ACTIVATION_DAYS`` (which should be the number of -# days after signup during which a user is allowed to -# 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) -# return self.activation_key == self.ACTIVATED or \ -# (self.user.date_joined + expiration_date <= datetime_now()) -# activation_key_expired.boolean = True -# -# def send_activation_email(self, site): -# """ -# Send an activation email to the user associated with this -# ``RegistrationProfile``. -# -# The activation email will make use of two templates: -# -# ``user_register_email_subject.txt`` -# This template will be used for the subject line of the -# email. Because it is used as the subject line of an email, -# this template's output **must** be only a single line of -# text; output longer than one line will be forcibly joined -# into only a single line. -# -# ``user_register_email.txt`` -# This template will be used for the body of the email. -# -# These templates will each receive the following context -# variables: -# -# ``activation_key`` -# The activation key for the new account. -# -# ``expiration_days`` -# The number of days remaining during which the account may -# be activated. -# -# ``site`` -# An object representing the site on which the user -# registered; depending on whether ``django.contrib.sites`` -# is installed, this may be an instance of either -# ``django.contrib.sites.models.Site`` (if the sites -# application is installed) or -# ``django.contrib.sites.models.RequestSite`` (if -# not). Consult the documentation for the Django sites -# framework for details regarding these objects' interfaces. -# -# """ -# ctx_dict = {'activation_key': self.activation_key, -# 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS, -# 'site': site} -# subject = render_to_string('user_register_email_subject.txt', -# ctx_dict) -# # Email subject *must not* contain newlines -# subject = ''.join(subject.splitlines()) -# -# message = render_to_string('user_register_email.txt', -# ctx_dict) -# -# send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.email]) -#DEPRECATED - - +class PendingAuthority(models.Model): + site_name = models.TextField() + site_authority = models.TextField() + site_abbreviated_name = models.TextField() + site_url = models.TextField() + site_latitude = models.TextField() + site_longitude = models.TextField() + address_line1 = models.TextField() + address_line2 = models.TextField() + address_line3 = models.TextField() + address_city = models.TextField() + address_postalcode = models.TextField() + address_state = models.TextField() + address_country = models.TextField() + # parent authority of the requested authority + authority_hrn = models.TextField() + created = models.DateTimeField(auto_now_add = True) + class PendingSlice(models.Model): slice_name = models.TextField() + user_hrn = models.TextField() authority_hrn = models.TextField(null=True) number_of_nodes = models.TextField(default=0) type_of_nodes = models.TextField(default='NA') purpose = models.TextField(default='NA') + created = models.DateTimeField(auto_now_add = True)