class RoleMembership(BaseMixin, db.Model): """Test model that grants multiple roles""" __tablename__ = 'role_membership' user_id = db.Column(None, db.ForeignKey('role_user.id')) user = db.relationship(RoleUser) doc_id = db.Column(None, db.ForeignKey('multirole_document.id')) doc = db.relationship('MultiroleDocument') role1 = db.Column(db.Boolean, default=False) role2 = db.Column(db.Boolean, default=False) role3 = db.Column(db.Boolean, default=False) @property def offered_roles(self): roles = set() if self.role1: roles.add('role1') if self.role2: roles.add('role2') if self.role3: roles.add('role3') return roles
class RoleGrantOne(BaseMixin, db.Model): """Test model for granting roles to users in a one-to-many relationship""" __tablename__ = 'role_grant_one' user_id = db.Column(None, db.ForeignKey('role_user.id')) user = with_roles(db.relationship(RoleUser), grants={'creator'})
class PolymorphicChild(PolymorphicParent): __tablename__ = 'polymorphic_child' id = db.Column(None, db.ForeignKey('polymorphic_parent.id', ondelete='CASCADE'), primary_key=True, nullable=False) # Redefining a column will keep existing annotations, even if not specified here also_immutable = db.Column(db.Unicode(250)) __mapper_args__ = {'polymorphic_identity': 'child'}
class MultiroleDocument(BaseMixin, db.Model): """Test model that grants multiple roles via RoleMembership""" __tablename__ = 'multirole_document' parent_id = db.Column(None, db.ForeignKey('multirole_parent.id')) parent = with_roles( db.relationship(MultiroleParent), # grants_via[None] implies that these roles are granted by parent.roles_for(), # and not via parent.`actor_attr`. While other roles may also be granted by # parent.roles_for(), we only want one, and we want to give it a different name # here. The dict maps source role to destination role. grants_via={None: { 'prole1': 'parent_prole1' }}, ) # Acquire parent_role through parent.user (a scalar relationship) # Acquire parent_other_role too (will be cached alongside parent_role) # Acquire role1 through both relationships (query and list relationships) # Acquire role2 and role3 via only one relationship each # This contrived setup is only to test that it works via all relationship types __roles__ = { 'parent_role': { 'granted_via': { 'parent': 'user' } }, 'parent_other_role': { 'granted_via': { 'parent': 'user' } }, 'role1': { 'granted_via': { 'rel_lazy': 'user', 'rel_list': 'user' } }, 'role2': { 'granted_via': { 'rel_lazy': 'user' } }, 'incorrectly_specified_role': { 'granted_via': { 'rel_list': None } }, } # Grant via a query relationship rel_lazy = db.relationship(RoleMembership, lazy='dynamic') # Grant via a list-like relationship rel_list = with_roles(db.relationship(RoleMembership), grants_via={'user': {'role3'}})
class RelationshipChild(BaseNameMixin, db.Model): __tablename__ = 'relationship_child' parent_id = db.Column(None, db.ForeignKey('relationship_parent.id'), nullable=False) __roles__ = {'all': {'read': {'name', 'title', 'parent'}}} __datasets__ = { 'primary': {'name', 'title', 'parent'}, 'related': {'name', 'title'}, }
class IdOnly(BaseMixin, db.Model): __tablename__ = 'id_only' __uuid_primary_key__ = False is_regular = db.Column(db.Integer) is_immutable = immutable(db.Column(db.Integer)) is_cached = cached(db.Column(db.Integer)) # Make the raw column immutable, but allow changes via the relationship referral_target_id = immutable( db.Column(None, db.ForeignKey('referral_target.id'), nullable=True)) referral_target = db.relationship(ReferralTarget)
class Subscription(BaseMixin, db.Model): __tablename__ = 'subscription' token = db.Column(db.Unicode(22), nullable=False, default=buid, unique=True) campaign_id = db.Column(None, db.ForeignKey('campaign.id'), nullable=False) campaign = db.relationship(Campaign, backref=db.backref( 'subscriptions', cascade='all, delete-orphan')) subscriber_id = db.Column(None, db.ForeignKey('subscriber.id'), nullable=False) subscriber = db.relationship(Subscriber, backref=db.backref( 'subscriptions', cascade='all, delete-orphan')) active = db.Column(db.Boolean, nullable=False, default=True) unsubscribed_at = db.Column(db.DateTime, nullable=True)
class ResponseTemplate(BaseNameMixin, db.Model): __tablename__ = 'response_template' auto_responder_id = db.Column(None, db.ForeignKey('auto_responder.id'), nullable=False) auto_responder = db.relationship(AutoResponder, backref=db.backref( 'templates', cascade='all, delete-orphan')) lang_code = db.Column(db.Unicode(3), nullable=False, default='en') body = db.Column(db.UnicodeText(), nullable=True)
class UuidOnly(UuidMixin, BaseMixin, db.Model): __tablename__ = 'uuid_only' __uuid_primary_key__ = True is_regular = db.Column(db.Unicode(250)) is_immutable = immutable(db.deferred(db.Column(db.Unicode(250)))) is_cached = cached(db.Column(db.Unicode(250))) # Make both raw column and relationship immutable referral_target_id = immutable( db.Column(None, db.ForeignKey('referral_target.id'), nullable=True)) referral_target = immutable(db.relationship(ReferralTarget))
class IdUuid(UuidMixin, BaseMixin, db.Model): __tablename__ = 'id_uuid' __uuid_primary_key__ = False is_regular = db.Column(db.Unicode(250)) is_immutable = immutable(db.Column(db.Unicode(250))) is_cached = cached(db.Column(db.Unicode(250))) # Only block changes via the relationship; raw column remains mutable referral_target_id = db.Column(None, db.ForeignKey('referral_target.id'), nullable=True) referral_target = immutable(db.relationship(ReferralTarget))
class RoleUser(BaseMixin, db.Model): """Test model represent a user who has roles""" __tablename__ = 'role_user' doc_id = db.Column(None, db.ForeignKey('role_grant_many.id')) doc = db.relationship( RoleGrantMany, foreign_keys=[doc_id], backref=db.backref('primary_users', lazy='dynamic'), ) secondary_docs = db.relationship( RoleGrantMany, secondary=granted_users, backref='secondary_users' )
class IncomingMessage(BaseMixin, db.Model): __tablename__ = 'incoming_message' __uuid_primary_key__ = True from_address = db.Column(db.Unicode(254), nullable=False) to_address = db.Column(db.Unicode(254), nullable=False) subject = db.Column(db.Unicode(255), nullable=False) headers = db.Column(db.UnicodeText(), nullable=False) messageid = db.Column(db.Unicode(255), nullable=False) body = db.Column(db.UnicodeText(), nullable=True) campaign_id = db.Column(None, db.ForeignKey('campaign.id'), nullable=False) campaign = db.relationship(Campaign, backref=db.backref( 'incoming_messages', cascade='all, delete-orphan'))
class MultiroleChild(BaseMixin, db.Model): """Model that inherits roles from its parent""" __tablename__ = 'multirole_child' parent_id = db.Column(None, db.ForeignKey('multirole_document.id')) parent = with_roles( db.relationship(MultiroleDocument), grants_via={ 'parent.user': {'super_parent_role'}, # Maps to parent.parent.user 'rel_lazy.user': { # Maps to parent.rel_lazy[item].user # Map role2 and role3, but explicitly ignore role1 'role2': 'parent_role2', 'role3': 'parent_role3', }, }, )
class OutgoingMessage(BaseMixin, db.Model): __tablename__ = 'outgoing_message' __uuid_primary_key__ = True to_addresses = db.Column(postgresql.ARRAY(db.Unicode(), dimensions=1), nullable=False) cc_list = db.Column(postgresql.ARRAY(db.Unicode(), dimensions=1), nullable=True) bcc_list = db.Column(postgresql.ARRAY(db.Unicode(), dimensions=1), nullable=True) subject = db.Column(db.Unicode(255), nullable=False) headers = db.Column(db.UnicodeText(), nullable=True) messageid = db.Column(db.Unicode(255), nullable=False) campaign_id = db.Column(None, db.ForeignKey('campaign.id'), nullable=False) campaign = db.relationship(Campaign, backref=db.backref( 'outgoing_messages', cascade='all, delete-orphan'))
class AutoResponder(BaseMixin, db.Model): __tablename__ = 'auto_responder' campaign_id = db.Column(None, db.ForeignKey('campaign.id'), nullable=False) campaign = db.relationship(Campaign, backref=db.backref( 'responders', cascade='all, delete-orphan')) subject = db.Column(db.Unicode(255), nullable=False) frequency = db.Column(db.Integer, default=RESPONDER_FREQUENCY.FIRST_TIME, nullable=False) def get_template(self, txt): lang_code, score = langid.classify(txt) template = ResponseTemplate.query.filter( ResponseTemplate.lang_code == lang_code).first() if not template: template = ResponseTemplate.query.filter( ResponseTemplate.lang_code == 'en').first() return template
class MultiroleParent(BaseMixin, db.Model): """Test model to serve as a role granter to the child model""" __tablename__ = 'multirole_parent' user_id = db.Column(None, db.ForeignKey('role_user.id')) user = with_roles(db.relationship(RoleUser), grants={'prole1', 'prole2'})
'primary': { 'name', 'title', 'children_list', 'children_set', 'children_dict_attr', 'children_dict_column', }, 'related': {'name', 'title'}, } granted_users = db.Table( 'granted_users', db.Model.metadata, db.Column('role_grant_many_id', None, db.ForeignKey('role_grant_many.id')), db.Column('role_user_id', None, db.ForeignKey('role_user.id')), ) RelationshipParent.children_names = DynamicAssociationProxy( 'children_list_lazy', 'name' ) class RoleGrantMany(BaseMixin, db.Model): """Test model for granting roles to users in many-to-one and many-to-many relationships""" __tablename__ = 'role_grant_many' __roles__ = {