class CharacterWeapons(Base): __tablename__ = 'character_weapons' character_id = db.Column(db.String(144), db.ForeignKey('character.id'), nullable=False) weapon_id = db.Column(db.String(144), db.ForeignKey('weapon.id'), nullable=False) character = db.relationship('Character', backref=db.backref( 'weapon_characters', cascade='all, delete-orphan')) weapon = db.relationship('Weapon', backref=db.backref('character_weapons', cascade='all, delete-orphan'))
class Task(Base): __tablename__ = 'task' name = db.Column(db.String(144), nullable=False) priority = db.Column(db.Integer, nullable=False) done = db.Column(db.Boolean, nullable=False) account_id = db.Column(db.Integer, db.ForeignKey('account.id'), nullable=False) tasks_and_categories = db.relationship('Category', secondary=tasks_and_categories, lazy='subquery', backref=db.backref('Task', lazy=True)) def __init__(self, name, priority, tasks_and_categories): self.name = name self.priority = priority self.done = False self.tasks_and_categories = tasks_and_categories def get_id(self): return self.id @staticmethod def categories_of_a_task(help_id): string = () stmt = text('SELECT category.name FROM task, category, tasks_and_categories' ' WHERE tasks_and_categories.task_id = ' + str(help_id) + ' AND tasks_and_categories.category_id = category.id' ' AND tasks_and_categories.task_id = task.id' ' ORDER BY category.name ASC') res = db.engine.execute(stmt) categories = [] for row in res: categories.append(row[0]) return categories
class User(db.Model, UserMixin): __tablename__ = "account" id = db.Column(db.Integer, primary_key=True) date_created = db.Column(db.DateTime, default=db.func.current_timestamp()) date_modified = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) name = db.Column(db.String(50), nullable=False) username = db.Column(db.String(50), unique=True, nullable=False) password = db.Column(db.String(50), nullable=False) logs = db.relationship("Log", backref='driver', lazy=True) roles = db.relationship('Role', secondary='user_roles', backref=db.backref('users', lazy='dynamic')) def __init__(self, name, username, password): self.name = name self.username = username self.password = bcrypt.generate_password_hash(password).decode("utf-8") def is_admin(self): rol = self.roles[0] return rol.name == 'ADMIN'
class FlicketGroup(Base): """ Flicket Group model class """ __tablename__ = 'flicket_group' id = db.Column(db.Integer, primary_key=True) group_name = db.Column(db.String(user_field_size['group_max'])) users = db.relationship(FlicketUser, secondary=flicket_groups, backref=db.backref('flicket_groups', lazy='dynamic', order_by=group_name)) # this is for when a group has many groups # ie everyone in group 'flicket_admin' can be a member of group 'all' # parents = db.relationship('Group', # secondary=group_to_group, # primaryjoin=id==group_to_group.c.parent_id, # secondaryjoin=id==group_to_group.c.child_id, # backref="children", # remote_side=[group_to_group.c.parent_id]) def __init__(self, group_name): self.group_name = group_name @property def __repr__(self): return self.group_name
class Notification(db.Model): """Basic notification. We create one notification per object per user. """ id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False) notification_object_id = db.Column(db.Integer(), db.ForeignKey('notification_object.id'), nullable=False) notification_object = db.relationship('NotificationObject', backref=db.backref('notification')) is_read = db.Column(db.Boolean(), default=False) date_read = db.Column(db.DateTime()) def get_subscription(self): context_object_type_id = self.notification_object.context_object_type_id context_object_id = self.notification_object.context_object_id notification_subscription = NotificationSubscriptions.query\ .filter(NotificationSubscriptions.context_object_type_id == context_object_type_id)\ .filter(NotificationSubscriptions.context_object_id == context_object_id)\ .filter(NotificationSubscriptions.user_id == current_user.id)\ .first() return notification_subscription @property def is_subscribed(self): subscription = self.get_subscription() if subscription: return subscription.is_subscribed else: return False def __str__(self): return u"Notification {0}".format(self.id)
class Category(db.Model): id = db.Column(db.Integer, primary_key=True) category = db.Column(db.String(100), nullable=False) account_id = db.Column(db.Integer, db.ForeignKey('account.id'), nullable=False) products = db.relationship("Product", backref=db.backref('category'), lazy=True) def __init__(self, category): self.category = category @staticmethod def list_categories_for_user(account=0): stmt = text( "SELECT Category.id, category, Category.account_id FROM Category" " JOIN account ON Category.account_id = account.id " " WHERE (Category.account_id = :account OR Category.account_id=0)" " ORDER BY Category.category").params(account=account) res = db.engine.execute(stmt) response = [] for row in res: response.append({ "id": row[0], "category": row[1], "account_id": row[2] }) return response
class RouterAlias(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) alias = db.Column(db.String(120)) router_id = db.Column(db.Integer, db.ForeignKey('router.id'), nullable=False) router = db.relationship('Router', backref=db.backref('aliases'))
class User(Base): __tablename__ = "account" username = db.Column(db.String(144), nullable=False, unique=True) password = db.Column(db.String(144), nullable=False) admin = db.Column(db.Boolean, nullable=False) kurssi = relationship('Varaus', backref=db.backref('varaus.kurssi')) def __init__(self, username, password, admin): self.username = username self.password = password self.admin = admin def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def roles(self): if self.admin is True: return ["ADMIN"] else: return ["NORMAL"]
class User(db.Model, UserMixin): __tablenaem__ = 'user' id = db.Column(db.Integer(), primary_key=True) email = db.Column(db.String(255), unique=True) fullname = db.Column(db.String(255)) _password = db.Column('password', db.String(255)) active = db.Column(db.Boolean(), default=False) create_at = db.Column(db.DateTime(), default=db.func.now()) posts = db.relationship('Post', backref='user', lazy='dynamic') roles = db.relationship('Role', secondary=roles_users, backref=db.backref('user', lazy='dynamic')) def __str__(self): return str(self.fullname) @hybrid_property def password(self): return self._password @password.setter def password(self, new_pass): if new_pass != self._password: new_password_hash = utils.hash_password(new_pass) self._password = new_password_hash
class Post(db.Model): # Сообщение id = db.Column(db.Integer, primary_key=True) category_id = db.Column( db.Integer, db.ForeignKey('category.id')) # ссылка на категорию author_id = db.Column(db.Integer, db.ForeignKey('author.id')) # ссылка на автора поста title = db.Column(db.String(80)) # название body = db.Column(db.Text) # текст поста image = db.Column(db.String(36)) # строка с hash на картинку slug = db.Column(db.String(255), unique=True) publish_date = db.Column(db.DateTime) # таймтстамп поста live = db.Column(db.Boolean) # видимость поста--удаление поста # связи между таблицами author = db.relationship('Author', backref=db.backref('posts', lazy='dynamic')) category = db.relationship('Category', backref=db.backref('posts', lazy='dynamic')) tags = db.relationship('Tag', secondary=tag_x_post, lazy='subquery', backref=db.backref('posts', lazy='dynamic')) def __init__(self, author, title, body, category=None, image=None, slug=None, publish_date=None, live=True): self.author_id = author.id self.title = title self.body = body self.image = image if category: self.category_id = category.id self.image = image self.slug = slug if publish_date is None: self.publish_date = datetime.utcnow() self.live = live def __repr__(self): return '<Post %r>' % self.title
class Task(Base): name = db.Column(db.String(30), nullable=False) state = db.Column(db.String(20), nullable=False) active = db.Column(db.Boolean, nullable=False) archived = db.Column(db.Boolean, nullable=False) description = db.Column(db.String(144), nullable=False) start_date = db.Column(db.DateTime, nullable=True) end_date = db.Column(db.DateTime, nullable=True) deadline = db.Column(db.DateTime, nullable=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=True) labels = db.relationship('Label', secondary='tasklabels', backref=db.backref('tasks'), lazy=True) def __init__(self, name, description, deadline): self.name = name self.state = "To-do" self.active = False self.archived = False self.description = description self.deadline = deadline @staticmethod def list_all_completed_tasks(user_id): stmt = text( "SELECT id, name, description, date_modified, state FROM Task " "WHERE (state = 'Completed') AND (user_id = :user_id)").params( user_id=user_id) res = db.engine.execute(stmt) response = [] for row in res: response.append({ "id": row[0], "name": row[1], "description": row[2], "date_modified": row[3], "state": row[4] }) return response @staticmethod def count_all_tasks(user_id): stmt = text("SELECT state, COUNT(id) AS count FROM Task " "WHERE (user_id = :user_id) " "GROUP BY state").params(user_id=user_id) res = db.engine.execute(stmt) response = [] for row in res: response.append({"state": row[0], "count": row[1]}) return response
class MatchRecord(db.Model): id = db.Column(db.Integer, primary_key=True) userid = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship('User', foreign_keys=[userid], backref=db.backref('room_list', cascade='all, delete-orphan', lazy='dynamic')) matchid = db.Column(db.Integer, db.ForeignKey('match.id')) match = db.relationship('Match', foreign_keys=[matchid], backref=db.backref('match_list', cascade='all, delete-orphan', lazy='dynamic')) point = db.Column(db.Integer) rebound = db.Column(db.Integer) assist = db.Column(db.Integer)
class Comment(db.Model): id = db.Column(db.Integer, primary_key = True) body = db.Column(db.Text()) created_time = db.Column(db.DateTime, default = db.func.now()) post_id = db.Column(db.Integer, db.ForeignKey('post.id')) post = db.relationship('Post', backref = db.backref('comments', cascade = 'all, delete-orphan', lazy = 'dynamic')) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship('User')
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) category_id = db.Column(db.Integer, db.ForeignKey('category.id')) author_id = db.Column(db.Integer, db.ForeignKey('author.id')) title = db.Column(db.String(80)) body = db.Column(db.Text) image = db.Column(db.String(36)) slug = db.Column(db.String(255)) publish_date = db.Column(db.DateTime) live = db.Column(db.Boolean) author = db.relationship('Author', backref=db.backref('posts', lazy='dynamic')) category = db.relationship('Category', backref=db.backref('posts', lazy='dynamic')) tags = db.relationship('Tag', secondary=tag_x_post, lazy='subquery', backref=db.backref('posts', lazy='dynamic')) def __init__(self, author, title, body, image=None, category=None, slug=None, publish_date=None, live=True): self.author_id = author.id self.title = title self.body = body self.image = image if category: self.category_id = category.id self.slug = slug if publish_date is None: self.publish_date = datetime.utcnow() self.live = live def __repr__(self): return '<Post {}>'.format(self.title)
class Event(db.Model): id = db.Column(db.Integer, primary_key=True) event_time = db.Column(db.DateTime) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship('User', backref=db.backref('events', lazy='dynamic')) tool_id = db.Column(db.Integer, db.ForeignKey('tool.id')) tool = db.relationship('Tool', backref=db.backref('events', lazy='dynamic')) message = db.Column(db.Text) def __init__(self, user_id, tool_id, message, event_time=None): if event_time is None: self.event_time = datetime.utcnow() self.user_id = user_id self.tool_id = tool_id self.message = message
class Comment(db.Model): """ 评论模型 """ __tablename__ = 'comment' id = db.Column(db.Integer(), primary_key=True, autoincrement=True) content = db.Column(db.Text, nullable=False) question_id = db.Column(db.Integer, db.ForeignKey('question.id')) author_id = db.Column(db.Integer, db.ForeignKey('user.id')) support = db.Column(db.Integer, default=0) create_time = db.Column(db.DateTime, default=datetime.now) # Question可以通过comments获取全部问题评论 question = db.relationship( 'Question', backref=db.backref('comments', order_by=id.desc())) # 根据id降序排序返回值 author = db.relationship( 'User', backref=db.backref('comments')) # User可以通过comments获取全部用户的评论
class User(Base): __tablename__ = "account" name = db.Column(db.String(30), nullable=False) username = db.Column(db.String(30), unique=True, nullable=False) password = db.Column(db.String(30), nullable=False) email = db.Column(db.String(30), unique=True, nullable=False) roles = db.relationship("Role", secondary=user_role, lazy="subquery", backref=db.backref("users", passive_deletes=True, lazy=True)) vnat = db.relationship("Vna", backref='account', passive_deletes=True, lazy=True) mmmat = db.relationship("Mmma", backref='account', passive_deletes=True, lazy=True) def __init__(self, name, username, password, email): self.name = name self.username = username self.password = password self.email = email def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def is_superuser(self): su_role = Role.query.filter_by(superuser=True).first() return su_role.name in self.get_roles() def set_default_role(self): user_role = Role.get_default_role() if user_role.name not in self.get_roles(): self.roles.append(user_role) db.session.commit() def get_roles(self): return [r.name for r in self.roles] def has_vna_with_id(self, vna_id): return any(p.id == int(vna_id) for p in self.vnat)
class User(UserMixin, db.Model): u""" 用户信息 """ __tablename__ = "user" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(64), unique=True, index=True, nullable=False) username = db.Column(db.String(64), nullable=False) tel_num = db.Column(db.String(11), unique=True, nullable=False) status = db.Column(db.Boolean, nullable=False, default=True) _password = db.Column(db.String(128), nullable=False) last = db.Column(db.DateTime) logs = db.relationship("Log", backref="user") roles = db.relationship("Role", secondary=user_role, backref=db.backref("user", lazy="dynamic")) @property def password(self): raise AttributeError("password is not a readable attribute") @password.setter def password(self, password): self._password = generate_password_hash(password) def check_password(self, password): return check_password_hash(self._password, password) def can(self, permission): # NOTE 验证权限 if permission in [ permission.name for role in self.roles for permission in role.permissions ]: return True else: return False def generate_menu(self): # NOTE 生成用户个性化菜单 menu_dict = collections.OrderedDict() child_menu = set() for role in self.roles: for permission in role.permissions: child_menu.update(permission.menus) parent_menu = child_menu & set(Menu.query.filter_by(pid=0).all()) child_menu = child_menu - parent_menu parent_menu = sorted(parent_menu, key=lambda key: key.display_order) for menu in parent_menu: if menu.url: menu_dict[menu.title] = menu.url else: menu_dict[menu.title] = collections.OrderedDict() _menu = [m for m in child_menu if m.pid == menu.id] _menu = sorted(_menu, key=lambda key: key.display_order) for c_menu in _menu: menu_dict[menu.title][c_menu.title] = c_menu.url return json.dumps(menu_dict)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) deleted = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) first_name = db.Column(db.String(255)) last_name = db.Column(db.String(255)) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(100)) current_login_ip = db.Column(db.String(100)) login_count = db.Column(db.Integer) signup_date = db.Column(db.DateTime(), default=datetime.datetime.now) karma = db.relationship('UserKarma', backref=db.backref('user'), uselist=False) roles = db.relationship('Role', secondary='roles_users', backref=db.backref('users', lazy='dynamic')) def gravatar(self, size=64): parameters = {'s': str(size), 'd': 'mm'} return "https://www.gravatar.com/avatar/" + \ hashlib.md5(self.email.lower()).hexdigest() + \ "?" + urllib.urlencode(parameters) def update_karma(self): self.karma.value = self.karma.positive - self.karma.negative db.session.commit() @property def string_id(self): return str(self.id) @property def role_ids(self): return [r.id for r in self.roles] # Required for administrative interface def __str__(self): return self.email
class Playlist(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), nullable=False) date_created = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) user_id = db.Column(db.Integer, nullable=False) songs_playlist = db.relationship('Song', secondary = 'songs_playlist', backref = db.backref('songs_playlist'), lazy='dynamic')
class Count(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) timestamp = db.Column(db.DateTime, nullable=False) devices = db.Column(db.Integer) router_id = db.Column(db.Integer, db.ForeignKey('router.id')) router = db.relationship('Router', backref=db.backref('counts', lazy=True)) def __repr__(self): return f'{self.router}@{self.timestamp}={self.devices}'
class Response(db.Model): id = db.Column(db.Integer, primary_key=True) form_id = db.Column(db.Integer, db.ForeignKey('form.id')) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) response = db.Column(db.String(200)) form = db.relationship('Form', backref=db.backref('responses', lazy='joined'), lazy='joined') user = db.relationship('User', backref=db.backref('filled_forms', lazy='joined'), lazy='joined') def __repr__(self): return '<Response user:{}, form:{}, response:{}>'.format( self.user, self.form, self.response)
class PlaceImage(db.Model): id = db.Column(db.Integer, primary_key=True) flickr_id = db.Column(db.BigInteger, unique=True, nullable=True) place_id = db.Column( db.Integer, db.ForeignKey('place.id', onupdate="CASCADE", ondelete="CASCADE")) place = db.relationship('Place', foreign_keys='PlaceImage.place_id', backref=db.backref('images', cascade='all, delete-orphan', lazy='dynamic')) thumbnail_url = db.Column(db.String(2048)) image_url = db.Column(db.String(2048)) like_count = db.Column(db.Integer, default='0', index=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id', onupdate="CASCADE", ondelete="SET NULL"), nullable=True) user = db.relationship('User', backref=db.backref('upload_images', cascade='all, delete-orphan', lazy='dynamic')) def like(self, user_id): image_like = ImageLike(place_image_id=self.id, user_id=user_id) self.like_count += 1 db.session.add(image_like) current_best_image = self.place.best_place_image if current_best_image and self.like_count > current_best_image.like_count: self.place.best_place_image_id = self.id self.place.image_url = self.image_url self.place.thumbnail_url = self.thumbnail_url db.session.commit() def is_liked_by(self, user_id): return self.liked_users.filter( ImageLike.user_id == user_id).count() > 0
class Comment(db.Model): id = db.Column(db.Integer, primary_key=True) body = db.Column(db.Text) like_count = db.Column(db.Integer, index=True, default='0') writed_time = db.Column(db.DateTime, default=db.func.now(), index=True) user_id = db.Column( db.Integer, db.ForeignKey('user.id', onupdate="CASCADE", ondelete="CASCADE")) user = db.relationship('User', backref=db.backref('comments', cascade='all, delete-orphan', lazy='dynamic')) place_id = db.Column( db.Integer, db.ForeignKey('place.id', onupdate="CASCADE", ondelete="CASCADE")) place = db.relationship('Place', foreign_keys='Comment.place_id', backref=db.backref('comments', cascade='all, delete-orphan', lazy='dynamic')) def is_liked_by(self, user_id): return self.likes.filter(CommentLike.user_id == user_id).count() == 1 def like(self, user_id): comment_like = CommentLike(user_id=user_id, comment_id=self.id) self.like_count += 1 if self.place.best_comment.like_count < self.like_count: self.place.best_comment_id = self.id db.session.add(comment_like) db.session.commit() def like_cancel(self, user_id): comment_like = CommentLike.query.filter( CommentLike.user_id == user_id, CommentLike.comment_id == self.id).one() self.like_count -= 1 db.session.delete(comment_like) db.session.commit()
class User(Base): __tablename__ = "account" name = db.Column(db.String(144), nullable=False) username = db.Column(db.String(144), nullable=False) password = db.Column(db.String(144), nullable=False) role = db.relationship('Role', secondary=user_role, backref=db.backref( 'accounts', lazy='dynamic')) threads = db.relationship("Thread", backref='account', lazy=True) def __init__(self, name, username, password): self.name = name self.username = username self.password = password def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True @staticmethod def comment_count(): stmt = text("SELECT name, COUNT(Comment.account_id) FROM account " "LEFT JOIN Comment ON account.id = Comment.account_id " "GROUP BY account.id") res = db.engine.execute(stmt) response = [] for row in res: response.append({"name":row[0], "amount":row[1]}) return response @staticmethod def thread_count(): stmt = text("SELECT name, COUNT(Thread.account_id) FROM account " "INNER JOIN Thread ON account.id = Thread.account_id " "GROUP BY account.id") res = db.engine.execute(stmt) response = [] for row in res: response.append({"user":row[0], "threads":row[1]}) return response
class BotUser(db.Model): __tablename__ = 'bot_user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(100)) first_name = db.Column(db.String(100)) last_name = db.Column(db.String(100)) answers = db.relationship('Answer', lazy='dynamic', backref=db.backref('user', lazy=True)) @staticmethod def add_user(user_id, first_name, last_name, username): current_user = BotUser.query.get(user_id) if current_user: return current_user new_user = BotUser(id=user_id, username=username, first_name=first_name, last_name=last_name) db.session.add(new_user) db.session.commit() return new_user def get_name(self): if self.last_name: return self.first_name + ' ' + self.last_name else: return self.first_name @staticmethod def get_by_id_and_channel_name(channel_name: str, user_id: int): channel = Channel.get_by_name(channel_name) if channel.is_member_exists(user_id): return channel, BotUser.query.get(user_id) else: return None, None @staticmethod def get_by_id(user_id: int): return BotUser.query.get(user_id) def get_answers_by_channel_id(self, channel_id: int): return self.answers.filter(Answer.channel_id == channel_id).all() def to_dict(self, include_answers=False): if include_answers: answers = self.answers.all() else: answers = [] return { 'id': self.id, 'username': self.username, 'firstName': self.first_name, 'lastName': self.last_name, 'answers': [a.to_dict() for a in answers] }
class Style(db.Model): __tablename__ = 'style' id = db.Column(db.Integer, primary_key=True) style_author_id = db.Column(db.Integer, db.ForeignKey('user.id')) description = db.Column(db.String(250), nullable=True) style_image = db.Column(db.LargeBinary) posts = db.relationship("SinglePost", backref="style") upvotes = db.Column(db.Integer, nullable=True) downvotes = db.Column(db.Integer, nullable=True) creation_date = db.Column(db.DateTime) isprivate = db.Column(db.Boolean) who_liked = db.relationship("User", secondary=who_liked_style, lazy='dynamic', backref=db.backref('liked_styles', lazy='dynamic')) tags = db.relation('Tag', secondary=style_tag_table, lazy='dynamic', backref=db.backref('styles', lazy='dynamic')) def __init__(self, author_id, style_image, description='Default description', localization="", isprivate=True): self.style_author_id = author_id self.description = description if (style_image is not None): self.style_image = style_image.encode('ascii') else: self.style_image = style_image self.result_image = None self.upvotes = 0 self.downvotes = 0 self.creation_date = dt.now() self.isprivate = isprivate def update(self, description, style_image, isprivate): self.description = description self.style_image = style_image self.isprivate = isprivate
class RaakaAine(Base, Nimellinen): kayttajaraakaaine = db.relationship('Resepti', secondary='liitostaulu', lazy='subquery', backref=db.backref('raakaaine', lazy=True)) def __init__(self, name): self.name = name
class UserSession(db.Model): __tablename__ = 'user_session' id = db.Column(db.Integer, primary_key=True) uid = db.Column(db.String(32), index=True, default=hex_uuid) created_at = db.Column(db.DateTime, default=datetime.utcnow) actions = db.relationship('UserAction', backref=db.backref('session'))
class User(db.Model, UserMixin): id = db.Column(db.Integer(), primary_key=True) email = db.Column(db.String(100), unique=True, nullable=False) password = db.Column(db.String(1000), nullable=False) active = db.Column(db.Boolean(), default=True) username = db.Column(db.String(15), unique=True, nullable=False) joined = db.Column(db.DateTime, default=datetime.now()) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) created_threads = db.relationship('Thread', backref='creator', lazy=True) secret_threads = db.relationship('Thread', secondary=secret_threads_users, backref=db.backref('secret_users', lazy=True)) messages = db.relationship('Message', backref='creator', lazy=True) def __repr__(self): return f'<User: {self.username}, id: {self.id}>'