pyramid-fullauth 0.4.0__py3.4.egg

pyramid_fullauth/events.py

@@ -0,0 +1,281 @@
+# 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 HTTPRedirection that might
+        be risen in event listener.
+
+    .. warning::
+        If HTTPRedirection 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 HTTPRedirection 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 HTTPRedirection 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 HTTPRedirection 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 HTTPRedirection 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 HTTPRedirection 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 HTTPRedirection that might
+        be risen in event listener.
+    """
+
+    pass
+
+
+class SocialAccountAlreadyConnected(_BaseSocialRegister):
+
+    """
+    Event raised when social account is already connected to some other user.
+
+
+    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 HTTPRedirection 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,190 @@
+# 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 datetime import datetime
+
+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.compat import text_type
+from pyramid_basemodel import Base
+
+from pyramid_fullauth import exceptions
+from pyramid_fullauth.models.mixins import UserPasswordMixin, UserEmailMixin
+
+
+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}')>".format(self.id)
+
+    def __unicode__(self):
+        """Unicode cast rules."""
+        if self.username:
+            return self.username
+        elif self.email:
+            return self.email.split('@')[0] + '@...'
+        else:
+            return text_type(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/extensions/__init__.py

@@ -0,0 +1,39 @@
+# Copyright (c) by SQLAlchemy authors and contributors.
+#
+# This module's code is part of SQLAlchemy's documentation
+# http://docs.sqlalchemy.org/en/rel_0_9/orm/extensions/hybrid.html#hybrid-value-objects
+# and released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""CaseInsensitive comparator for sqlalchemy models."""
+
+from sqlalchemy import func
+from sqlalchemy.ext.hybrid import Comparator
+from pyramid.compat import string_types
+
+
+class CaseInsensitive(Comparator):
+
+    """Hybrid value representing a lower case representation."""
+
+    def __init__(self, word):
+        """Initialise comparator object."""
+        if isinstance(word, string_types):
+            self.word = word.lower()
+        elif isinstance(word, CaseInsensitive):
+            self.word = word.word
+        else:
+            self.word = func.lower(word)
+
+    def operate(self, op, other):
+        """Operate."""
+        if not isinstance(other, CaseInsensitive):
+            other = CaseInsensitive(other)
+        return op(self.word, other.word)
+
+    def __clause_element__(self):
+        """Get clause element for comparator.."""
+        return self.word
+
+    def __str__(self):
+        """Cast element to."""
+        return self.word

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)