class MastodonAuth(db.Model):
__tablename__ = "mastodon_auths"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship("User", back_populates="mastodon_auth")
created_at = db.Column(db.DateTime, nullable=False)
app_id = db.Column(db.Integer,
db.ForeignKey('mastodon_apps.id'),
nullable=False)
app = db.relationship("MastodonApp", back_populates="auths")
generated_on = db.Column(db.DateTime, nullable=True)
access_token = db.Column(db.String(255), nullable=True)
mastodon_id = db.Column(db.Integer, nullable=True)
username = db.Column(db.String(255), nullable=True)
def __init__(self, user_id, app_id):
self.user_id = user_id
self.app_id = app_id
self.created_at = datetime.datetime.now()
def update_account(self, access_token, mastodon_id, username):
self.access_token = access_token
self.generated_on = datetime.datetime.now()
self.mastodon_id = mastodon_id
self.username = username
class AdditiveRuleLink(db.Model):
__tablename__ = "additive_rule_links"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
rule_id = db.Column(db.Integer, db.ForeignKey('rules.id'), nullable=False)
source = db.Column(db.String(255), nullable=False)
uri = db.Column(db.String(255), nullable=False)
display_name = db.Column(db.String(255), nullable=False)
display_uri = db.Column(db.String(255))
level = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
last_modified = db.Column(db.DateTime, nullable=False)
rule = db.relationship("AdditiveRule", back_populates="additive_links")
db.PrimaryKeyConstraint('rule_id', 'uri')
def __init__(self, rule_id, source, uri, level, name, display_uri):
self.rule_id = rule_id
self.source = source
self.uri = uri
self.display_name = name
self.display_uri = display_uri
self.level = level
self.created_at = datetime.datetime.now()
self.last_modified = datetime.datetime.now()
def serialize(self):
return {
'id': self.id,
'uri': self.display_uri or self.uri,
'name': self.display_name,
'level': self.level,
}
class SettingsUpdate(db.Model):
__tablename__ = "settings_updates"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
update_time = db.Column(db.DateTime, nullable=False)
new_settings = db.Column(db.JSON, nullable=False)
def __init__(self, user_id, new_settings):
self.user_id = user_id
self.update_time = datetime.datetime.now()
self.new_settings = new_settings
class Rule(db.Model):
__tablename__ = "rules"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
creator_user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
creator_display_name = db.Column(db.String(255), nullable=False)
title = db.Column(db.String(255), nullable=False)
description = db.Column(db.String(255), nullable=False)
long_description = db.Column(db.String(510))
source = db.Column(db.String(255), nullable=False)
shareable = db.Column(db.Boolean, nullable=False)
link = db.Column(db.String(255))
exclude_terms = db.Column(ARRAY(db.String(255)))
level_display_names = db.Column(ARRAY(db.String(255)))
control_display_name = db.Column(db.String(255))
type = db.Column(db.String(255), nullable=False) # e.g. additive, keyword
created_at = db.Column(db.DateTime, nullable=False)
last_modified = db.Column(db.DateTime, nullable=False)
user_associations = db.relationship("UserRule",
back_populates="rule",
cascade="delete, delete-orphan")
__mapper_args__ = {
'polymorphic_on': type,
}
def __init__(self, creator_user_id, creator_display_name, title,
description, long_description, shareable, source, link,
rule_type):
self.creator_user_id = creator_user_id
self.creator_display_name = creator_display_name
self.title = title
self.description = description
self.long_description = long_description
self.shareable = shareable
self.source = source
self.link = link
self.created_at = datetime.datetime.now()
self.last_modified = datetime.datetime.now()
self.type = rule_type
def serialize(self):
return {
'id': self.id,
'creator_display_name': self.creator_display_name,
'title': self.title,
'description': self.description,
'long_description': self.long_description,
'link': self.link,
'type': self.type,
}
class UserRule(db.Model):
__tablename__ = "users_rules"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
rule_id = db.Column(db.Integer, db.ForeignKey('rules.id'), nullable=False)
enabled = db.Column(db.Boolean, nullable=False)
levels = db.Column(ARRAY(db.Integer))
created_at = db.Column(db.DateTime, nullable=False)
last_modified = db.Column(db.DateTime, nullable=False)
rule = db.relationship("Rule", back_populates="user_associations")
user = db.relationship("User", back_populates="rule_associations")
db.UniqueConstraint('user_id', 'rule_id')
def __init__(self, user_id, rule_id, enabled=False, levels=None):
self.user_id = user_id
self.rule_id = rule_id
self.levels = levels
self.enabled = enabled
self.created_at = datetime.datetime.now()
self.last_modified = datetime.datetime.now()
class TwitterAuth(db.Model):
__tablename__ = "twitter_auths"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship("User", back_populates="twitter_auth")
generated_on = db.Column(db.DateTime, nullable=False)
oauth_token = db.Column(db.String(255), nullable=False)
oauth_token_secret = db.Column(db.String(255), nullable=False)
def __init__(self, user_id, oauth_token, oauth_token_secret):
self.user_id = user_id
self.generated_on = datetime.datetime.now()
self.oauth_token = oauth_token
self.oauth_token_secret = oauth_token_secret
class PostAdditiveRule(db.Model):
__tablename__ = "posts_additive_rules"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
rule_id = db.Column(db.Integer,
db.ForeignKey('rules.id', ondelete='CASCADE'),
nullable=False)
post_id = db.Column(db.Integer,
db.ForeignKey('posts.id', ondelete='CASCADE'),
nullable=False)
level = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
last_modified = db.Column(db.DateTime, nullable=False)
db.PrimaryKeyConstraint('rule_id', 'post_id')
post = db.relationship("Post", back_populates="rule_associations")
rule = db.relationship("AdditiveRule", back_populates="post_associations")
def __init__(self, rule_id, post_id, level):
self.rule_id = rule_id
self.post_id = post_id
self.level = level
self.created_at = datetime.datetime.now()
self.last_modified = datetime.datetime.now()
class Settings(db.Model):
__tablename__ = "user_settings"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship("User", back_populates="settings")
rudeness_min = db.Column(db.Float,
db.CheckConstraint('rudeness_min>=0'),
default=0)
rudeness_max = db.Column(db.Float,
db.CheckConstraint('rudeness_max<=1'),
default=1)
gender_filter_on = db.Column(db.Boolean, default=False)
gender_female_per = db.Column(
db.Integer,
db.CheckConstraint('gender_female_per>=0 AND gender_female_per<=100'),
default=50)
include_corporate = db.Column(db.Boolean, default=True)
virality_min = db.Column(db.Float,
db.CheckConstraint('virality_min>=0'),
default=0)
virality_max = db.Column(db.Float,
db.CheckConstraint('virality_max<=1'),
default=1)
seriousness_min = db.Column(db.Float,
db.CheckConstraint('seriousness_min>=0'),
default=0)
seriousness_max = db.Column(db.Float,
db.CheckConstraint('seriousness_max<=1'),
default=1)
rudeness_ck = db.CheckConstraint('rudeness_max>rudeness_min')
virality_ck = db.CheckConstraint('virality_max>virality_min')
seriousness_ck = db.CheckConstraint('seriousness_max>seriousness_min')
def as_dict(self):
d = {c.name: getattr(self, c.name) for c in self.__table__.columns}
return d
def update(self, settings_dict):
self.rudeness_min = settings_dict['rudeness_min']
self.rudeness_max = settings_dict['rudeness_max']
self.gender_filter_on = settings_dict['gender_filter_on']
self.gender_female_per = settings_dict['gender_female_per']
self.include_corporate = settings_dict['include_corporate']
self.virality_min = settings_dict['virality_min']
self.virality_max = settings_dict['virality_max']
self.seriousness_min = settings_dict['seriousness_min']
self.seriousness_max = settings_dict['seriousness_max']
class FacebookAuth(db.Model):
__tablename__ = "facebook_auths"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship("User", back_populates="facebook_auth")
generated_on = db.Column(db.DateTime, nullable=False)
access_token = db.Column(db.String(255), nullable=False)
token_type = db.Column(db.String(255), nullable=False)
expires_in = db.Column(db.DateTime, nullable=False)
def __init__(self, user_id, facebook_auth_data):
self.user_id = user_id
self.generated_on = datetime.datetime.now()
self.access_token = facebook_auth_data['access_token']
self.token_type = facebook_auth_data['token_type']
self.expires_in = self.generated_on + datetime.timedelta(seconds=int(facebook_auth_data['expires_in']))
import datetime
from server.core import db, bcrypt
from server.enums import GenderEnum, PoliticsEnum, EchoRangeEnum
post_associations_table = db.Table('posts_associations', db.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('post_id', db.Integer, db.ForeignKey('posts.id')),
db.PrimaryKeyConstraint('user_id', 'post_id'),
)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
completed_registration = db.Column(db.Boolean, default=False)
facebook_name = db.Column(db.String(255))
facebook_picture_url = db.Column(db.String(255))
facebook_id = db.Column(db.String(255))
facebook_email = db.Column(db.String(255))
twitter_name = db.Column(db.String(255))
twitter_id = db.Column(db.String(255))
facebook_auth = db.relationship("FacebookAuth", uselist=False, back_populates="user", cascade="delete, delete-orphan")
twitter_auth = db.relationship("TwitterAuth", uselist=False, back_populates="user", cascade="delete, delete-orphan")
twitter_authorized = db.Column(db.Boolean, nullable=False, default=False)
