Account follower and project registration models

funnel/models/__init__.py

@@ -61,6 +61,8 @@
 from .project import * # isort:skip
 from .update import * # isort:skip
 from .proposal import * # isort:skip
+from .follower import * # isort:skip
+from .registration import * # isort:skip
 from .rsvp import * # isort:skip
 from .saved import * # isort:skip
 from .session import * # isort:skip

funnel/models/follower.py

@@ -0,0 +1,71 @@
+"""Project registration."""
+
+from __future__ import annotations
+
+from coaster.sqlalchemy import immutable, with_roles
+
+from . import Mapped, db, sa
+from .membership_mixin import ActorMembershipMixin
+from .profile import Profile
+
+__all__ = ['Follower']
+
+
+class Follower(ActorMembershipMixin, db.Model): # type: ignore[name-defined]
+ """A user can register on a project."""
+
+ __tablename__ = 'follower'
+
+ __roles__ = {
+ 'all': {
+ 'read': {'urls', 'user'},
+ 'call': {'url_for'},
+ },
+ }
+ __datasets__ = {
+ 'primary': {
+ 'urls',
+ 'uuid_b58',
+ 'offered_roles',
+ 'user',
+ 'project',
+ },
+ 'without_parent': {
+ 'urls',
+ 'uuid_b58',
+ 'offered_roles',
+ 'user',
+ },
+ 'related': {
+ 'urls',
+ 'uuid_b58',
+ 'offered_roles',
+ },
+ }
+
+ profile_id: Mapped[int] = immutable(
+ with_roles(
+ sa.orm.mapped_column(
+ None, sa.ForeignKey('profile.id', ondelete='CASCADE'), nullable=False
+ ),
+ read={'subject', 'editor'},
+ ),
+ )
+ profile: Mapped[Profile] = immutable(
+ with_roles(
+ sa.orm.relationship(
+ Profile,
+ backref=sa.orm.backref(
+ 'all_memberships',
+ lazy='dynamic',
+ cascade='all',
+ passive_deletes=True,
+ ),
+ ),
+ read={'subject', 'editor'},
+ grants_via={None: {'editor'}},
+ ),
+ )
+ parent: Mapped[Profile] = sa.orm.synonym('profile') # type: ignore[assignment]
+ parent_id: Mapped[int] = sa.orm.synonym('profile_id') # type: ignore[assignment]
+ parent_id_column = 'profile_id'

funnel/models/membership_mixin.py

@@ -14,6 +14,7 @@
  TypeVar,
  Union,
 )
+from uuid import UUID
 
 from sqlalchemy import event
 from sqlalchemy.sql.expression import ColumnElement
@@ -29,12 +30,15 @@
  BaseMixin,
  Mapped,
  UuidMixin,
+ UUIDType,
  db,
  declarative_mixin,
  declared_attr,
  hybrid_property,
  sa,
 )
+from .email_address import EmailAddress
+from .phone_number import PhoneNumber
 from .profile import Profile
 from .reorder_mixin import ReorderMixin
 from .user import EnumerateMembershipsMixin, User
@@ -51,7 +55,7 @@
 
 MembershipType = TypeVar('MembershipType', bound='ImmutableMembershipMixin')
 FrozenAttributionType = TypeVar('FrozenAttributionType', bound='FrozenAttributionMixin')
-SubjectType = Union[Mapped[User], Mapped[Profile]]
+SubjectType = Union[User, Profile]
 
 # --- Enum -----------------------------------------------------------------------------
 
@@ -393,7 +397,7 @@ def user(cls) -> Mapped[User]:
 
  @declared_attr
  @classmethod
- def subject(cls) -> Mapped[User]:
+ def subject(cls) -> Mapped[User]: # type: ignore[override]
  """Subject of this membership record."""
  return sa.orm.synonym('user')
 
@@ -515,7 +519,7 @@ def profile(cls) -> Mapped[Profile]:
 
  @declared_attr
  @classmethod
- def subject(cls) -> Mapped[Profile]:
+ def subject(cls) -> Mapped[Profile]: # type: ignore[override]
  """Subject of this membership record."""
  return sa.orm.synonym('profile')
 
@@ -724,6 +728,249 @@ def freeze_subject_attribution(
  return membership
 
 
+@declarative_mixin
+class ActorMembershipMixin(FrozenAttributionMixin, ImmutableMembershipMixin):
+ """Provide a base for membership models that accept a user or a contact address."""
+
+ __tablename__: str # Defined by subclasses
+ __data_columns__ = ('user', 'email_address', 'phone_number', 'browserid')
+
+ @declared_attr
+ @classmethod
+ def user_id(cls) -> Mapped[int]:
+ """Foreign key column to user table."""
+ return sa.orm.mapped_column(
+ sa.Integer,
+ sa.ForeignKey('user.id', ondelete='CASCADE'),
+ nullable=True,
+ index=True,
+ )
+
+ @with_roles(read={'subject', 'editor'}, grants={'subject'})
+ @declared_attr
+ @classmethod
+ def user(cls) -> Mapped[User]:
+ """User who is the subject of this membership record."""
+ return sa.orm.relationship(User, foreign_keys=[cls.user_id])
+
+ @declared_attr
+ @classmethod
+ def subject(cls) -> Mapped[User]: # type: ignore[override]
+ """Subject of this membership record."""
+ return sa.orm.synonym('user')
+
+ @declared_attr
+ @classmethod
+ def email_address_id(cls) -> Mapped[int]:
+ return sa.orm.mapped_column(
+ sa.Integer, sa.ForeignKey('email_address.id'), nullable=True
+ )
+
+ @declared_attr
+ @classmethod
+ def email_address(cls) -> Mapped[EmailAddress]:
+ """Instance of :class:`EmailAddress` as a relationship."""
+ backref_name = 'used_in_' + cls.__tablename__
+ EmailAddress.__backrefs__.add(backref_name)
+ return sa.orm.relationship(
+ EmailAddress,
+ backref=sa.orm.backref(
+ backref_name,
+ primaryjoin=sa.and_(
+ cls.email_address_id == EmailAddress.id, cls.revoked_at.isnot(None)
+ ),
+ ),
+ )
+
+ @declared_attr
+ @classmethod
+ def phone_number_id(cls) -> Mapped[int]:
+ return sa.orm.mapped_column(
+ sa.Integer, sa.ForeignKey('phone_number.id'), nullable=True
+ )
+
+ @declared_attr
+ @classmethod
+ def phone_number(cls) -> Mapped[PhoneNumber]:
+ """Instance of :class:`PhoneNumber` as a relationship."""
+ backref_name = 'used_in_' + cls.__tablename__
+ PhoneNumber.__backrefs__.add(backref_name)
+ return sa.orm.relationship(
+ PhoneNumber,
+ backref=sa.orm.backref(
+ backref_name,
+ primaryjoin=sa.and_(
+ cls.phone_number_id == PhoneNumber.id, cls.revoked_at.isnot(None)
+ ),
+ ),
+ )
+
+ @declared_attr
+ @classmethod
+ def browserid(cls) -> Mapped[UUID]: # TODO: Plug into larger framework
+ """Random identifier for anonymous user's browser (saved to cookie)."""
+ return sa.orm.mapped_column(UUIDType(binary=False), nullable=True)
+
+ @declared_attr.directive
+ @classmethod
+ def __table_args__(cls) -> tuple:
+ """Table arguments for SQLAlchemy."""
+ return (
+ (
+ sa.Index(
+ 'ix_' + cls.__tablename__ + '_user_active',
+ cls.parent_id_column,
+ 'user_id',
+ unique=True,
+ postgresql_where='revoked_at IS NULL AND user_id IS NOT NULL',
+ ),
+ sa.Index(
+ 'ix_' + cls.__tablename__ + '_email_active',
+ cls.parent_id_column,
+ 'email_address_id',
+ unique=True,
+ postgresql_where=(
+ 'revoked_at IS NULL AND email_address_id IS NOT NULL'
+ ),
+ ),
+ sa.Index(
+ 'ix_' + cls.__tablename__ + '_phone_active',
+ cls.parent_id_column,
+ 'phone_number_id',
+ unique=True,
+ postgresql_where=(
+ 'revoked_at IS NULL AND phone_number_id IS NOT NULL'
+ ),
+ ),
+ )
+ if cls.parent_id_column is not None
+ else (
+ sa.Index(
+ 'ix_' + cls.__tablename__ + '_user_active',
+ 'user_id',
+ unique=True,
+ postgresql_where='revoked_at IS NULL AND user_id IS NOT NULL',
+ ),
+ sa.Index(
+ 'ix_' + cls.__tablename__ + '_email_active',
+ 'email_address_id',
+ unique=True,
+ postgresql_where=(
+ 'revoked_at IS NULL AND email_address_id IS NOT NULL'
+ ),
+ ),
+ sa.Index(
+ 'ix_' + cls.__tablename__ + '_phone_active',
+ 'phone_number_id',
+ unique=True,
+ postgresql_where=(
+ 'revoked_at IS NULL AND phone_number_id IS NOT NULL'
+ ),
+ ),
+ )
+ ) + (
+ sa.CheckConstraint(
+ sa.or_(
+ # User must be present, or
+ sa.column('user_id').isnot(None),
+ # If user is not present, one of phone number or email address must
+ # be present
+ sa.and_(
+ sa.column('user_id').is_(None),
+ sa.or_(
+ sa.column('email_address_id').isnot(None),
+ sa.column('phone_number_id').isnot(None),
+ ),
+ ),
+ )
+ ),
+ )
+
+ @hybrid_property
+ def is_self_granted(self) -> bool:
+ """Return True if the subject of this record is also the granting actor."""
+ return self.user_id == self.granted_by_id
+
+ with_roles(is_self_granted, read={'subject', 'editor'})
+
+ @hybrid_property
+ def is_self_revoked(self) -> bool:
+ """Return True if the subject of this record is also the revoking actor."""
+ return self.user_id == self.revoked_by_id
+
+ with_roles(is_self_revoked, read={'subject', 'editor'})
+
+ def copy_template(self: MembershipType, **kwargs) -> MembershipType:
+ return type(self)(
+ user=self.user,
+ email_address=self.email_address,
+ phone_number=self.phone_number,
+ browserid=self.browserid,
+ **kwargs,
+ )
+
+ @property
+ def email_address_reference_is_active(self) -> bool:
+ return self.is_active
+
+ @property
+ def phone_number_reference_is_active(self) -> bool:
+ return self.is_active
+
+ @classmethod
+ def migrate_user( # type: ignore[return]
+ cls, old_user: User, new_user: User
+ ) -> OptionalMigratedTables:
+ """
+ Migrate memberhip records from one user to another.
+
+ If both users have active records, they are merged into a new record in the new
+ user's favour. All revoked records for the old user are transferred to the new
+ user.
+ """
+ # Look up all active membership records of the subclass's type for the old user
+ # account. `cls` here represents the subclass.
+ old_user_records = cls.query.filter(
+ cls.user == old_user, cls.revoked_at.is_(None)
+ ).all()
+ # Look up all conflicting memberships for the new user account. Limit lookups by
+ # parent except when the membership type doesn't have a parent (SiteMembership).
+ if cls.parent_id is not None:
+ new_user_records = cls.query.filter(
+ cls.user == new_user,
+ cls.revoked_at.is_(None),
+ cls.parent_id.in_([r.parent_id for r in old_user_records]),
+ ).all()
+ else:
+ new_user_records = cls.query.filter(
+ cls.user == new_user,
+ cls.revoked_at.is_(None),
+ ).all()
+ new_user_records_by_parent = {r.parent_id: r for r in new_user_records}
+
+ for record in old_user_records:
+ if record.parent_id in new_user_records_by_parent:
+ # Where there is a conflict, merge the records
+ new_user_records_by_parent[record.parent_id].merge_and_replace(
+ new_user, record
+ )
+ db.session.flush()
+
+ # Transfer all revoked records and non-conflicting active records. At this point
+ # no filter is necessary as the conflicting records have all been merged.
+ cls.query.filter(cls.user == old_user).update(
+ {'user_id': new_user.id}, synchronize_session=False
+ )
+ # Also update the revoked_by and granted_by user accounts
+ cls.query.filter(cls.revoked_by == old_user).update(
+ {'revoked_by_id': new_user.id}, synchronize_session=False
+ )
+ cls.query.filter(cls.granted_by == old_user).update(
+ {'granted_by_id': new_user.id}, synchronize_session=False
+ )
+ db.session.flush()
+
+
 class AmendMembership(Generic[MembershipType]):
  """
  Helper class for editing a membership record from a form.