pyramid-fullauth 0.3.0__py2.7.egg

pyramid_fullauth/events.py

@@ -0,0 +1,267 @@
+# Copyright (c) 2013 - 2014 by pyramid_fullauth authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_fullauth and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+
+"""pyramid_fullauth emits these events during whole cycle."""
+
+
+class _BaseRegisterEvent(object):
+
+    """
+    Base fullauth event.
+
+    most of the fullauth's event will provide both request and user
+    object with some additional data (these will be described then).
+    """
+
+    def __init__(self, request, user):
+        """
+        Initialize event.
+
+        :param pyramid.request.Request request: request object
+        :param pyramid_fullauth.models.User user: user object
+        """
+        self.request = request
+        self.user = user
+
+
+class BeforeRegister(_BaseRegisterEvent):
+
+    """
+    Execute custom code at the start of registration process.
+
+    .. note::
+
+        User object is not yet in session.
+    """
+
+    def __init__(self, request, user, errors):
+        """
+        Initialize event.
+
+        :param pyramid.request.Request request: request object
+        :param pyramid_fullauth.models.User user: user object
+        :param dict errors: a dictionary with wrong/not submitted fields
+            with format - fields for which error occured: error message
+        """
+        _BaseRegisterEvent.__init__(self, request, user)
+        self.errors = errors
+
+
+class AfterRegister(_BaseRegisterEvent):
+
+    """
+    Add custom post-processing code in registration process.
+
+    Can be used to add e.g. e-mail sending with registration links.
+
+    .. note::
+        User object is already in a session.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+
+    .. warning::
+        If HTTPFound is risen from event listener, then response_values will not be used!
+
+    """
+
+    def __init__(self, request, user, response_values):
+        """
+        Initialize event.
+
+        :param pyramid.request.Request request: request object
+        :param pyramid_fullauth.models.User user: user object
+        :param dict response_values: a dictionary with response values
+        """
+        _BaseRegisterEvent.__init__(self, request, user)
+        self.response_values = response_values
+
+
+class AfterActivate(_BaseRegisterEvent):
+
+    """
+    Add custom post-processing logic after user gets activated.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+    """
+
+    pass
+
+
+class AfterResetRequest(_BaseRegisterEvent):
+
+    """
+    Add custom post-processing after user sends request to reset password.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+    """
+
+    pass
+
+
+class BeforeReset(_BaseRegisterEvent):
+
+    """Add custom pre-processing before the actual reset-password process."""
+
+    pass
+
+
+class AfterReset(_BaseRegisterEvent):
+
+    """
+    Add custom post-processing after the actual reset-password process.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+    """
+
+    pass
+
+
+class AlreadyLoggedIn(object):
+
+    """
+    Allow execute custom logic, when logged in user tries to log in again.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+
+    """
+
+    def __init__(self, request):
+        """
+        Initialize event.
+
+        :param pyramid.request.Request request: request object
+        """
+        self.request = request
+
+
+class BeforeLogIn(_BaseRegisterEvent):
+
+    """
+    Add custom logic before user gets logged in.
+
+    .. note::
+        Action emitting this event, should catch all AttributeError that might be risen in event listener.
+        User param set to None when user is not found or request method is GET.
+    """
+
+    pass
+
+
+class AfterLogIn(_BaseRegisterEvent):
+
+    """Add custom logic after user logs in."""
+
+    pass
+
+
+# Social events
+# TODO: extract to sub module
+
+
+class _BaseSocialRegister(_BaseRegisterEvent):
+
+    """Base for all social requests."""
+
+    def __init__(self, request, user, profile):
+        """
+        Initialize base events.
+
+        :param pyramid.request.Request request: request object
+        :param pyramid_fullauth.models.User user: user object
+        :param dict profile: a dictionary with profile data
+        """
+        _BaseRegisterEvent.__init__(self, request, user)
+        self.profile = profile
+
+
+class BeforeSocialRegister(_BaseSocialRegister):
+
+    """Adds custom logic before the social login process start."""
+
+    pass
+
+
+class AfterSocialRegister(_BaseSocialRegister):
+
+    """
+    Add custom logic after user registers through social network.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+    """
+
+    def __init__(self, request, user, profile, response_values):
+        """
+        Initialize event.
+
+        :param pyramid.request.Request request: request object
+        :param pyramid_fullauth.models.User user: user object
+        :param dict profile: a dictionary with profile data
+        :param dict response_values: a dictionary with response values
+        """
+        _BaseSocialRegister.__init__(self, request, user, profile)
+        self.response_values = response_values
+
+
+class AfterSocialLogIn(_BaseSocialRegister):
+
+    """
+    Custom logic after user logs in through social network.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+    """
+
+    pass
+
+
+class SocialAccountAlreadyConnected(_BaseSocialRegister):
+
+    """
+    Allow to add custom logic, when someone tries to connect social account to second user in application.
+
+    .. note::
+        Action emitting this event, should catch all HTTPFound that might be risen in event listener.
+    """
+
+    def __init__(self, request, user, profile, response_values):
+        """
+        Initialize event.
+
+        :param pyramid.request.Request request: request object
+        :param pyramid_fullauth.models.User user: user object
+        :param dict profile: a dictionary with profile data
+        :param dict response_values: a dictionary with response values
+        """
+        _BaseSocialRegister.__init__(self, request, user, profile)
+        self.response_values = response_values
+
+# Email change events.
+
+
+class BeforeEmailChange(_BaseRegisterEvent):
+
+    """Allow to add custom validation (like checking password) before email change process."""
+
+    pass
+
+
+class AfterEmailChange(_BaseRegisterEvent):
+
+    """Allow to add some custom post-processing, like e-mail sending, after email change process."""
+
+    pass
+
+
+class AfterEmailChangeActivation(_BaseRegisterEvent):
+
+    """Allow to add custom logic, after changed email had been activated."""
+
+    pass

pyramid_fullauth/exceptions.py

@@ -0,0 +1,47 @@
+# Copyright (c) 2013 - 2014 by pyramid_fullauth authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_fullauth and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Fullauth's exceptions definition."""
+
+
+class DeleteException(Exception):
+
+    """Exception risen when the user can't be deleted."""
+
+    pass
+
+
+class ValidateError(ValueError):
+
+    """Base of every validate error in pyramid_fullauth."""
+
+    pass
+
+
+class EmptyError(ValidateError):
+
+    """Thrown whenever user is trying to set empty value."""
+
+    pass
+
+
+class ShortPasswordError(ValidateError):
+
+    """Thrown when password doesn't meet the length requirement."""
+
+    pass
+
+
+class PasswordConfirmMismatchError(ValidateError):
+
+    """Thrown when there's a mismatch with cpassword_confirm."""
+
+    pass
+
+
+class EmailValidationError(ValidateError):
+
+    """Exception thrown, when there's incorrect email provided."""
+
+    pass

pyramid_fullauth/models/__init__.py

@@ -0,0 +1,189 @@
+# Copyright (c) 2013 - 2014 by pyramid_fullauth authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_fullauth and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Models needed for registration, and user servicing."""
+
+import sys
+import uuid
+
+from sqlalchemy import (
+    Column, Unicode, String, Integer, Boolean, Sequence, DateTime,
+    Table, ForeignKey, UniqueConstraint
+)
+from sqlalchemy.sql import func
+from sqlalchemy.orm import validates, relationship
+from sqlalchemy.orm.session import object_session
+from sqlalchemy.orm.util import has_identity
+
+from pyramid_basemodel import Base
+from pyramid_fullauth import exceptions
+from pyramid_fullauth.models.mixins import UserPasswordMixin, UserEmailMixin
+from datetime import datetime
+
+
+class User(UserPasswordMixin, UserEmailMixin, Base):
+
+    """User object."""
+
+    __tablename__ = 'users'
+
+    id = Column(Integer, Sequence(__tablename__ + '_sq'), primary_key=True)
+    username = Column(Unicode(32), unique=True, nullable=True)
+    firstname = Column(Unicode(100), nullable=True)
+    lastname = Column(Unicode(100), nullable=True)
+    activate_key = Column(String(255), default=lambda: str(uuid.uuid4()), unique=True)
+    address_ip = Column(String(15), nullable=False)
+
+    registered_at = Column(DateTime, default=func.now(), nullable=False)
+    logged_at = Column(DateTime, default=func.now(), nullable=False)
+    activated_at = Column(DateTime, nullable=True)
+    deactivated_at = Column(DateTime, nullable=True)
+    deleted_at = Column(DateTime, nullable=True)
+
+    is_admin = Column(Boolean, default=False, nullable=False)
+
+    @property
+    def is_active(self):
+        """
+        Check if user is active.
+
+        :returns: Returns False if user account is not active (or deleted).
+        :rtype: bool
+
+        """
+        return not (self.deactivated_at or self.deleted_at or self.activate_key) and bool(self.activated_at)
+
+    @is_active.setter
+    def is_active(self, value):
+        """
+        Set user as active/inactive.
+
+        :param bood value:
+            True - removes deactivated_at, deleted_at, activate_key and set activated_at to datetime now
+            False - set deactivated_at to now and activated_at to None
+
+        """
+        # Allow to modify this only if object is in the persistent state to prevent "default values" errors/bugs.
+        # http://stackoverflow.com/questions/3885601/sqlalchemy-get-object-instance-state
+        if object_session(self) is not None and has_identity(self):
+            if value:
+                self.deactivated_at = None
+                self.deleted_at = None
+                self.activate_key = None
+                self.activated_at = datetime.now()
+            else:
+                self.deactivated_at = datetime.now()
+                self.activated_at = None
+        else:
+            raise AttributeError('User has to be in the persistent state - stored in the DB')
+
+    def provider_id(self, provider):
+        """
+        Return provider identification for give user.
+
+        :param str provider: provider name
+        :returns: provider identification
+        :rtype: str
+
+        """
+        for user_provider in self.providers:
+            if user_provider.provider == provider:
+                return user_provider.provider_id
+
+    def __repr__(self):
+        """Object representation."""
+        return "<User ('{0}', '{1}')>".format(self.id, str(self))
+
+    def __unicode__(self):
+        """Unicode cast rules."""
+        if self.username:
+            return self.username
+        elif self.email:
+            return self.email.split('@')[0] + '@...'
+        else:
+            return str(self.id)
+
+    def __str__(self):  # pragma: no cover
+        """String cast rules."""
+        if sys.version[0] == '3':
+            return self.__unicode__()
+        else:
+            return self.__unicode__().encode('utf-8')
+
+    @validates('is_admin')
+    def validate_is_admin(self, key, value):
+        """
+        Validate is_admin value, we forbid the deletion of the last superadmin.
+
+        .. note::
+
+            More about simple validators: http://docs.sqlalchemy.org/en/latest/orm/mapper_config.html#simple-validators
+
+        :raises AttributeError: Information about an error
+
+        """
+        if self.is_admin and not value:
+            admin_counter = object_session(self).query(User).filter(
+                User.is_admin, User.deleted_at.is_(None)
+            ).count()
+            if admin_counter and admin_counter <= 1:
+                raise AttributeError('Can\'t delete last superadmin!')
+        return value
+
+    def delete(self):
+        """
+        Perform soft delete action. along with checking if it's super admin, or not.
+
+        :rises pyramid_fullauth.exceptions.DeleteException: if you try to delete last super admin.
+
+        .. note::
+            You should use this method to delete users
+
+        """
+        if self.is_admin:
+            admin_counter = object_session(self).query(User).filter(
+                User.is_admin, User.deleted_at.is_(None)
+            ).count()
+            if admin_counter and admin_counter <= 1:
+                raise exceptions.DeleteException('Can\'t delete last superadmin!')
+
+        self.deleted_at = datetime.now()
+
+
+class Group(Base):
+
+    """User group object."""
+
+    __tablename__ = 'groups'
+
+    id = Column(Integer, Sequence(__tablename__ + '_sq'), primary_key=True)
+    name = Column(Unicode(100), unique=True, nullable=False)
+
+    #: Relation to User object
+    users = relationship(User, secondary=lambda: user_group, backref='groups')
+
+
+class AuthenticationProvider(Base):
+
+    """Model to store authentication methods for different providers."""
+
+    __tablename__ = 'user_authentication_provider'
+
+    __table_args__ = (
+        UniqueConstraint('provider', 'provider_id', name='user_authentication_methods_provider_id'),
+    )
+
+    user_id = Column(Integer, ForeignKey(User.id), primary_key=True)
+    provider = Column(Unicode(15), primary_key=True)
+    provider_id = Column(String(255), nullable=False)
+
+    user = relationship(User, backref='providers')
+
+#: Association table between User and Group models.
+user_group = Table(
+    'users_groups',
+    Base.metadata,
+    Column('user_id', Integer, ForeignKey(User.id), primary_key=True),
+    Column('group_id', Integer, ForeignKey(Group.id), primary_key=True)
+)

pyramid_fullauth/models/mixins/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2013 - 2014 by pyramid_fullauth authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_fullauth and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+
+from pyramid_fullauth.models.mixins.password import UserPasswordMixin
+from pyramid_fullauth.models.mixins.email import UserEmailMixin
+
+__all__ = (UserPasswordMixin, UserEmailMixin)

pyramid_fullauth/models/mixins/email.py

@@ -0,0 +1,81 @@
+# Copyright (c) 2013 - 2014 by pyramid_fullauth authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_fullauth and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Email mixin related module."""
+
+import re
+import uuid
+
+from sqlalchemy import Column
+from sqlalchemy import Unicode
+from sqlalchemy import String
+from sqlalchemy.orm import validates
+
+
+from pyramid_fullauth.exceptions import EmptyError, EmailValidationError
+
+pattern_mail = re.compile(
+    r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]{0,256}(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+){0,256}"  # dot-atom
+    # quoted-string, see also http://tools.ietf.org/html/rfc2822#section-3.2.5
+    r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177 ]|\\[\001-\011\013\014\016-\177 ]){0,256}"'
+    r')@((?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2}\.?)$)'  # domain
+    r'|\[(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\]$', re.IGNORECASE)  # literal form, ipv4 address (SMTP 4.1.3)
+
+
+class UserEmailMixin(object):
+
+    """User email fields and functionality."""
+
+    __pattern_mail = pattern_mail
+
+    email = Column(Unicode(254), unique=True, nullable=False)  # RFC5321 and RFC3696(errata)
+    new_email = Column(Unicode(254), unique=True, nullable=True)  # RFC5321 and RFC3696(errata)
+    email_change_key = Column(String(255), default=None, unique=True)
+
+    @validates('email', 'new_email')
+    def validate_email(self, key, address):
+        """
+        Validate email addresses.
+
+        .. note::
+
+            See pyramid docs about `simple validators <http://docs.sqlalchemy.org/en/latest/orm/mapper_config.html#simple-validators>`_
+
+        :param str key: field key
+        :param str address: email address
+
+        :raises EmailValidationError:
+        :raises EmptyError:
+        """
+        if address:
+            if pattern_mail.match(address):
+                return address
+            else:
+                raise EmailValidationError('Incorrect e-mail format')
+
+        raise EmptyError('E-mail is empty')
+
+    def set_new_email(self, email_new):
+        """
+        Set new email and generate new email change hash.
+
+        :param str email_new: email address
+
+        :returns: generated email_change_key
+        :trype: str
+
+        """
+        self.new_email = email_new
+        self.email_change_key = str(uuid.uuid4())
+        return self.email_change_key
+
+    def change_email(self):
+        """
+        Change email after activation.
+
+        We don't clear new email field because of validator of email which won't allow to None value.
+
+        """
+        self.email = self.new_email
+        self.email_change_key = None