class Item(UserMixin, db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
item_name = db.Column(db.String(50), nullable=False, unique=False)
time = db.Column(db.String(50), nullable=True, unique=False)
timestamp = db.Column(db.DateTime, default=datetime.now)
uploader_id = db.Column(db.Integer, db.ForeignKey('users.id'))
uploader = db.relationship('User',
backref=db.backref('items', lazy='dynamic'))
status = db.Column(db.String(50), nullable=False, unique=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=True)
category = db.relationship('Category', backref=db.backref('items'))
location = db.Column(db.String(50), nullable=True, unique=False)
description = db.Column(db.String(400), nullable=True, unique=False)
comment = db.relationship('Comment', backref=db.backref('items'))
pic = db.Column(db.String(64), default='img/a1.jpg')
store_location_id = db.Column(db.Integer,
db.ForeignKey('store_location.id'),
nullable=True)
store_location = db.relationship('Storage', backref=db.backref('items'))
# store_location = db.relationship('Storage', backref=db.backref('items',lazy='dynamic'))
def __repr__(self):
return self.item_name
class Product(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False, index=True)
email = db.Column(db.String(120), nullable=True)
slug = db.Column(db.String(120), unique=True, nullable=False, index=True)
product_group_id = db.Column(db.Integer(),
db.ForeignKey('product_group.id'),
nullable=False)
objectives = db.relationship('Objective',
backref=db.backref('product', lazy='joined'),
lazy='dynamic',
passive_deletes=True)
indicators = db.relationship('Indicator',
backref=db.backref('product', lazy='joined'),
lazy='dynamic',
passive_deletes=True)
username = db.Column(db.String(120), default='')
created = db.Column(db.DateTime(), default=datetime.utcnow)
updated = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
def get_owner(self):
return self.product_group.name
def __repr__(self):
return '<Product {}>'.format(self.name)
class Cast(db.Model):
""" Cast Model represents SQL Cast Table as a conjunction table between
Movies and People in them.
Attributes:
movie_id (str) -- Foreign key of Movie table
character_id (str) -- Foreign Key of Character Table
"""
movie_id = db.Column(db.String,
db.ForeignKey('movie.id'),
primary_key=True)
character_id = db.Column(db.String,
db.ForeignKey('character.id'),
primary_key=True)
movie = db.relationship(Movie,
backref=db.backref("cast",
cascade="all, delete-orphan"))
character = db.relationship(Character,
backref=db.backref(
"cast", cascade="all, delete-orphan"))
__tablename__ = 'cast'
def __init__(self, movie, person):
self.movie_id = movie
self.character_id = person
class Question(QuestionJsonSerializer, db.Model, TimeStampMixin):
__tablename__ = 'questions'
id = db.Column(db.Integer, primary_key=True)
# risk_id and type_id could be null in case the question is a subfield of enum
risk_id = db.Column(db.Integer, db.ForeignKey('risks.id'))
type_id = db.Column(db.Integer, db.ForeignKey('field_types.id'))
'''
Text of the question could be anything like 'What is your first name?'
or simply 'First name'. Other examples are age, zip code, model, serial number
'''
text = db.Column(db.String)
# if a field is a subfield of enum then it will have parent id too.
# Field with type Enum could only be a parent of other fields.
parent_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
type_ = db.relationship('FieldType')
options = db.relationship('Question',
remote_side=[parent_id],
backref=db.backref('mcq', remote_side=[id]))
risk = db.relationship('Risk', backref=db.backref('questions'))
def __str__(self):
return u'{0}-{1}-{2}-{3}-{4}'.format(self.id, self.risk_id,
self.type_id, self.text,
self.text, self.parent_id)
class Encounter(db.Model, FeatherModel):
"""
Encounters database model.
"""
guid = db.Column(
db.GUID, default=uuid.uuid4, primary_key=True
) # pylint: disable=invalid-name
from app.modules.sightings.models import Sighting
sighting_guid = db.Column(
db.GUID, db.ForeignKey('sighting.guid'), index=True, nullable=True
)
sighting = db.relationship('Sighting', backref=db.backref('encounters'))
owner_guid = db.Column(db.GUID, db.ForeignKey('user.guid'), index=True, nullable=True)
owner = db.relationship('User', backref=db.backref('owned_encounters'))
title = db.Column(db.String(length=50), nullable=False)
public = db.Column(db.Boolean, default=False, nullable=False)
projects = db.relationship('ProjectEncounter', back_populates='encounter')
def __repr__(self):
return (
'<{class_name}('
'guid={self.guid}, '
"title='{self.title},'"
'owner={self.owner},'
')>'.format(class_name=self.__class__.__name__, self=self)
)
@db.validates('title')
def validate_title(self, key, title): # pylint: disable=unused-argument,no-self-use
if len(title) < 3:
raise ValueError('Title has to be at least 3 characters long.')
return title
def get_owner(self):
return self.owner
def get_sighting(self):
return self.sighting
def is_public(self):
if self.public is True or self.owner is None:
return True
def has_read_permission(self, obj):
# todo, check if the encounter owns the sighting once Colin's sightings code is merged in
# if isinstance(obj, Sighting):
# check sightings array
# else look to see if the object is owned by any sighting
return False
class Application(ApplicationJsonSerializer, db.Model, TimeStampMixin):
__tablename__ = 'applications'
id = db.Column(db.Integer, primary_key=True)
risk_id = db.Column(db.Integer, db.ForeignKey('risks.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
risk = db.relationship('Risk', backref=db.backref('applications'))
anwsers = db.relationship('Answer', backref=db.backref('application'))
def __str__(self):
return u'{0}-{1}-{2}'.format(self.id, self.risk_id, self.user_id)
class LessonUser(db.Model):
__tablename__ = "lesson_user"
__table_args__ = (
UniqueConstraint("lesson_id", "user_id", name="_lesson_user_unique"),
{"extend_existing": True},
)
lesson_id = db.Column(
db.String(36), db.ForeignKey("lesson.id", ondelete="CASCADE"), primary_key=True
)
user_id = db.Column(
db.String(36), db.ForeignKey("user.id", ondelete="CASCADE"), primary_key=True
)
status = db.Column(
db.Enum(UserLessonStatus),
server_default="INPROGRESS",
index=True,
nullable=False,
)
lesson = db.relationship(
"Lesson",
# back_populates="users",
backref=db.backref(
"lu_users", cascade="save-update, merge, " "delete, delete-orphan"
),
)
user = db.relationship(
"User",
# back_populates="lessons",
backref=db.backref(
"lu_lessons", cascade="save-update, merge, " "delete, delete-orphan"
),
)
def __init__(self, lesson_id, user_id, status: UserLessonStatus):
self.lesson_id = lesson_id
self.user_id = user_id
self.status = status
def save_to_db(self):
"""
Saves Lesson to Database
Returns:
"""
try:
db.session.add(self)
db.session.commit()
return True
except:
db.session.rollback()
raise
class Message(UserMixin, db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
timestamp = db.Column(db.DateTime, default=datetime.now)
sender_id = db.Column(db.Integer, db.ForeignKey('users.id'))
store_location_id = db.Column(db.Integer,
db.ForeignKey('store_location.id'))
sender = db.relationship('User', backref=db.backref('messages'))
store_location = db.relationship('Storage', backref=db.backref('messages'))
is_recieve = db.Column(db.Boolean, default=False)
title = db.Column(db.String(50), nullable=True, unique=False)
content = db.Column(db.String(400), nullable=True, unique=False)
def __repr__(self):
return self.id
class WebSite(db.Model, BaseModel):
id = Column(INTEGER, primary_key=True)
name = Column(String(256), unique=True, nullable=False)
description = Column(String(516), nullable=True)
url = Column(String(516), unique=True, nullable=False)
thumb = Column(TEXT, nullable=True)
create_date = Column(db.DateTime, nullable=False, default=datetime.utcnow)
category_id = Column(INTEGER, ForeignKey("category.id"), nullable=True)
category = db.relationship("Category",
backref=db.backref("websites"),
lazy=True)
def __init__(self, name: str, description: str, url: str, thumb: str,
category: Union['Category', None]):
self.name = name
self.description = description
self.url = url
self.thumb = thumb
self.category = category
def to_dict(self):
payload: dict = {
"id": self.id, # noqa
"name": self.name,
"description": self.description,
"url": self.url,
"thumb": self.thumb,
"create_date": str(self.create_date),
"category_id": self.category_id,
}
return payload
class User(db.Model, UserMixin):
"""Data model for user accounts."""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(25), unique=True, nullable=False)
password = db.Column(db.String(256), nullable=True)
two_factor = db.Column(db.String(11), unique=False, nullable=False)
roles = db.relationship(
"Role",
secondary=role_association,
lazy="subquery",
backref=db.backref("users", lazy=True),
)
questions = db.relationship("Question", back_populates="user", lazy=True)
auth_histories = db.relationship("AuthHistory", backref="user", lazy=True)
def set_password(self, password):
""" convenience function to generate the hashed user password """
self.password = generate_password_hash(password)
def check_password(self, value):
""" convenience function to check that the supplied password matches the hash """
return check_password_hash(self.password, value)
def check_two_factor(self, value):
return self.two_factor == value
def __repr__(self):
return f"<User {self.username}>"
class Users(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(64), unique=True)
confirmed = db.Column(db.Boolean, default=False)
icon = db.Column(db.String(64), default='default.jpg')
posts = db.relationship('Posts', backref='user')
favorites = db.relationship('Posts',
secondary='collections',
backref=db.backref('users', lazy='dynamic'),
lazy='dynamic')
@property
def password(self):
raise AttributeError('密码不可读')
@password.setter
def password(self, passwrod):
self.password_hash = generate_password_hash(passwrod)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def generate_active_token(self, expires_in=3600):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': self.id})
@staticmethod
def check_activate_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
u = Users.query.get(data.get('id'))
if not u:
return False
if not u.confirmed:
u.confirmed = True
db.session.commit()
return True
def is_favorite(self, uid):
favorites = self.favorites.all()
posts = list(filter(lambda p: p.id == uid, favorites))
if len(posts) > 0:
return True
return False
def add_favorite(self, uid):
p = Posts.query.get(uid)
self.favorites.append(p)
def def_favorite(self, uid):
p = Posts.query.get(uid)
self.favorites.remove(p)
class State(db.Model):
"""Basic state model
"""
__tablename__ = "states"
id = db.Column(db.Integer, primary_key=True)
game_id = db.Column(db.Integer, db.ForeignKey("games.id"), nullable=False)
game = db.relationship('Game', backref=db.backref('states'))
# gold in a budget
gold = db.Column(db.Integer, nullable=False, default=0)
# population in a city
population = db.Column(db.Integer, nullable=False, default=0)
# army in a city (<= population)
army = db.Column(db.Integer, nullable=False, default=0)
# enemies around a city
enemies = db.Column(db.Integer, nullable=False, default=0)
# reaction move
reaction_move = db.Column(db.Text, nullable=True, default=None)
def __init__(self, **kwargs):
super(State, self).__init__(**kwargs)
def __repr__(self):
return "<State %s>" % self.id
class Objective(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.Text(), nullable=False)
description = db.Column(db.Text(), default='')
product_id = db.Column(db.Integer(),
db.ForeignKey('product.id', ondelete='CASCADE'),
index=True)
targets = db.relationship('Target',
backref=db.backref('objective', lazy='joined'),
passive_deletes=True)
username = db.Column(db.String(120), default='')
created = db.Column(db.DateTime(), default=datetime.utcnow)
updated = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
def get_owner(self):
return self.product.product_group.name
def __repr__(self):
return '<SLO {} | {}>'.format(self.product.name, self.title)
class PasswordAuthentication(db.Model):
"""Password Authentication model.
Pangea will support multiple authentication modes, each stored separately.
"""
__tablename__ = 'password_authentication'
user_uuid = db.Column(UUID(as_uuid=True),
db.ForeignKey('users.uuid'),
primary_key=True,
unique=True)
password = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
# One-to-one relationship with User
user = db.relationship('User',
backref=db.backref('password_authentication',
uselist=False))
def __init__(self,
password,
user_uuid=None,
created_at=datetime.datetime.utcnow()):
"""Initialize MetaGenScope User model."""
if user_uuid:
self.user_uuid = user_uuid
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.created_at = created_at
class Column(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(100))
type = db.Column(db.String(50))
length = db.Column(db.String(10))
format = db.Column(db.String(50))
table_id = db.Column(db.Integer, db.ForeignKey('table.id'))
table = db.relationship("Table", backref=db.backref('columns', lazy='dynamic', cascade="all,delete"))
def __repr__(self):
return self.name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'name': self.name,
'description': self.description,
'type': self.type,
'length': self.type,
'format': self.format,
'table': self.table.name,
'location': self.table.location.name
}
@property
def serialize_table(self):
"""
Return object's relations in easily serializeable format.
NB! Calls the tables serialize property.
"""
return [item.serialize for item in self.table]
class User(db.Model):
id = db.Column(db.String(36), primary_key=True)
login = db.Column(db.String(50), unique=True, nullable=False)
display_name = db.Column(db.String(50))
password_hash = db.Column(db.String(), nullable=False)
roles = db.relationship('Role',
secondary=user_roles,
lazy='subquery',
backref=db.backref('users', lazy=True))
@property
def password(self):
raise AttributeError('Password is not a readable')
def get_role_names(self):
return [role.display_name for role in self.roles]
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return f"<User display_name={self.display_name} roles={self.roles}"
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), index=True, unique=True)
password = db.Column(db.String(128))
salt = db.Column(db.String(10))
email = db.Column(db.String(128), index=True, unique=True)
# relationships
posts = db.relationship('Post', backref='author', lazy='dynamic')
injuries = db.relationship('Injury', backref='author', lazy='dynamic')
likes = db.relationship('Like', backref='author', lazy='dynamic')
runs = db.relationship('Run', backref='author', lazy='dynamic')
followed = db.relationship('User',
secondary=follower,
primaryjoin=(follower.c.id == id),
secondaryjoin=(follower.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def set_password(self, password):
abc = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
self.salt = ''.join([choice(abc) for _ in range(10)])
self.password = generate_password_hash(password + self.salt)
def check_password(self, password):
return check_password_hash(self.password, password + self.salt)
def is_following(self, user):
return self.followed.filter(
follower.c.followed_id == user.id).count() > 0
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
class Organization(db.Model):
"""A formally or informally recognized grouping of people or organizations formed for the purpose of achieving
some form of collective action. Includes companies, institutions, corporations, departments, community groups,
healthcare practice groups, etc."""
__tablename__ = 'organization'
__mapper_args__ = {'extension': BaseExtension()}
id = db.Column(db.Integer, primary_key=True)
parent_id = db.Column(db.Integer,
db.ForeignKey('organization.id'),
index=True)
name = db.Column(db.Text, nullable=False)
type = db.Column(db.Text, index=True)
default = db.Column(db.Boolean, default=False)
active = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow())
updated_at = db.Column(db.DateTime)
children = db.relationship('Organization',
backref=db.backref('parent', remote_side=[id]))
def __repr__(self): # pragma: no cover
return '<Organization {}:{}>'.format(self.id, self.name)
def before_insert(self):
pass
def before_update(self):
pass
class Waitlist(BaseModel, db.Model):
__tablename__ = 'waitlist'
initial_score = 65231
decrease_per_referral = 10
uuid = db.Column(db.String(8), primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', back_populates='waitlist')
score = db.Column(db.Integer)
referred = db.relationship('Waitlist',
secondary=referrals,
primaryjoin=(referrals.c.referring == uuid),
secondaryjoin=(referrals.c.referred == uuid),
backref=db.backref('referral', lazy='dynamic'),
lazy='dynamic')
def __init__(self, user_id):
self.user_id = user_id
self.set_uuid()
self.set_initial_score()
def set_uuid(self):
uuid = utils.generate_simple_uuid(8)
while db.session.query(Waitlist).filter_by(uuid=uuid).one_or_none():
uuid = utils.generate_simple_uuid(8)
self.uuid = uuid
def set_initial_score(self):
self.score = self.initial_score + db.session.query(
Waitlist).count() + 1
class Picture(db.Model):
id = db.Column(db.Integer, primary_key=True)
despriction = db.Column(db.String(5000), unique=True)
address = db.Column(db.String(35), unique=True)
userId = db.Column(db.Integer, db.ForeignKey('User.id'))
tags = db.relationship('Tags',
secondary=relation,
backref=db.backref('picture', lazy='dynamic'))
commnet = db.relationship('Comments', backref='picture', lazy='dynamic')
def to_json(self):
taglist = []
for tag in self.tags:
taglist.append(tag.to_json)
commlist = []
for comment in self.comments:
commlist.append(comment.to_json)
json_pic = {
'id': str(self.id),
'userid': self.userId,
'dsepriction': self.despriction,
'adress': self.address,
'tags': taglist,
'comments': commlist
}
return json_pic
class Recipe(db.Model):
"""Табличка рецепта"""
__tablename__ = 'recipe'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
img_url = db.Column(db.String, nullable=False, unique=True)
literature_url = db.Column(db.String, nullable=False, unique=True)
time_on_preparation = db.Column(db.String,
CheckConstraint('time_on_preparation>0'),
nullable=False)
time_on_cooking = db.Column(db.String,
CheckConstraint('time_on_cooking>0'),
nullable=False)
dish_id = db.Column(
db.Integer,
db.ForeignKey('dish.id', ondelete="CASCADE", onupdate="CASCADE"))
steps_of_cook = db.relationship('StepOfCook', backref='recipe')
implements = db.relationship('Implement',
secondary=RECIPE_AND_IMPLEMENT,
backref=db.backref('recipes', lazy='dynamic'))
def __init__(self, img_url, literature_url, time_on_preparation,
time_on_cooking, dish_id):
self.img_url = img_url
self.literature_url = literature_url
self.time_on_preparation = time_on_preparation
self.time_on_cooking = time_on_cooking
self.dish_id = dish_id
def __repr__(self):
return f"Recipe({self.id}, {self.img_url}, {self.literature_url}, {self.time_on_preparation}," \
f" {self.time_on_cooking}, {self.dish_id})"
class Article(db.Model):
article_id = db.Column(db.String(64), primary_key=True)
article_title = db.Column(db.String(255))
article_url = db.Column(db.String(255))
article_desc = db.Column(db.Text)
article_content = db.Column(db.Text)
site_id = db.Column(db.String(64), db.ForeignKey('web_site.site_id'))
tags = db.relationship('Tag', secondary=tags,
backref=db.backref('articles', lazy='dynamic'))
create_time = db.Column(db.DateTime)
def __init__(self, article_title='', article_url='', article_desc='',
article_content='', site_id=None, *args, **kwargs):
super(Article, self).__init__(*args, **kwargs)
self.article_id = str(uuid.uuid4())
self.article_title = article_title
self.article_url = article_url
self.article_desc = article_desc
self.article_content = article_content
self.site_id = site_id
db.session.add(self)
db.session.commit()
def set_tags(self, a_tags):
self.tags = a_tags
db.session.add(self)
db.session.commit()
def __unicode__(self):
return u"Article: {}".format(self.article_title)
class User(db.Model, UserMixin, GetOrCreateMixin, GetOr404Mixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String)
full_name = db.Column(db.String)
inbox_email = db.Column(db.String(255), unique=True)
active = db.Column(db.Boolean)
confirmed_at = db.Column(db.DateTime)
roles = db.relationship('Role',
secondary=user_roles,
backref=db.backref('users', lazy='dynamic'))
@classmethod
def get_or_create(cls, **kwargs):
try:
user = User.query.filter_by(**kwargs).one()
except NoResultFound:
user = User(**kwargs)
db.session.add(user)
db.session.commit()
except MultipleResultsFound:
raise
return user
class Post(PaginatedAPIMixin, db.Model):
"""文章模型类"""
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
summary = db.Column(db.Text)
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime(), index=True, default=datetime.utcnow)
views = db.Column(db.Integer, default=0)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
comments = db.relationship('Comment',
backref='post',
lazy='dynamic',
cascade='all,delete-orphan')
# 喜欢博客的人和被喜欢的文章是多对多的关系,一个人可以喜欢多个文章,一个文章可以被多个人喜欢
likers = db.relationship('User',
secondary=posts_likes,
backref=db.backref('liked_posts', lazy='dynamic'),
lazy="dynamic")
def __repr__(self):
return "<POST{}>".format(self.title)
def from_dict(self, data: dict):
"""接收表单数据构建post对象并返回"""
for filed in ["title", "body", "summary"]:
if filed in data:
setattr(self, filed, data[filed])
def to_dict(self):
data = {
'id': self.id,
'title': self.title,
'body': self.body,
'summary': self.summary,
'author_id': self.author_id,
'_links': {
'self': url_for('api.get_post', id=self.id),
'author_url': url_for('api.get_users', id=self.author_id)
}
}
return data
def is_liked_by(self, user):
"""是否收藏过文章"""
return user in self.likers
def liked_by(self, user):
"""收藏文章"""
if not self.is_liked_by(user):
self.likers.append(user)
def unliked_by(self, user):
"""取消收藏文章"""
if self.is_liked_by(user):
self.likers.remove(user)
class Expense(db.Model):
expense_id = db.Column(db.String(36), primary_key=True)
user_id = db.Column(db.String(36), nullable=False)
amount = db.Column(db.Float(), nullable=False)
description = db.Column(db.String(100))
created_at = db.Column(db.DateTime, default=func.now())
category_id = db.Column(
db.String(36), db.ForeignKey("category.category_id"))
category = db.relationship(Category, backref=db.backref('expenses'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class Employee(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(), unique=True, nullable=False)
completed_task = db.Column(db.Integer(), default=0, nullable=False)
tasks = db.relationship("Task",
secondary=task_empl,
backref=db.backref("empls"),
lazy="dynamic")
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(255), unique=True, nullable=False)
display_name = db.Column(db.String(255))
password = db.Column(db.String(255))
last_login_time = db.Column(db.DateTime,
default=datetime.datetime.utcnow())
super_powered = db.Column(db.Boolean, default=False)
ratings = db.relationship('DailyRating', backref=db.backref('user'))
daily_stats = db.relationship('DailySummary', backref=db.backref('user'))
def dump(self):
return {
'username': self.username,
'display_name': self.display_name,
'last_login_time': self.last_login_time
}
class Card(db.Model):
__tablename__ = "card"
__table_args__ = {"extend_existing": True}
id = db.Column(db.String(36), primary_key=True, default=str(uuid.uuid4()))
lesson_id = db.Column(
db.String(36),
db.ForeignKey("lesson.id", ondelete="CASCADE"),
nullable=False,
index=True,
)
text = db.Column(db.BLOB, nullable=False)
updated_at = db.Column(db.DateTime, nullable=True)
created_at = db.Column(db.DateTime, nullable=False)
lesson = db.relationship(
"Lesson",
foreign_keys=lesson_id,
backref=db.backref("card", lazy="select", cascade="all,delete"),
)
def __init__(self, lesson_id, text):
self.lesson_id = lesson_id
self.text = text
def save_to_db(self):
"""
Saves Card to Database
Returns:
"""
try:
self.updated_at = datetime.datetime.utcnow()
self.created_at = datetime.datetime.utcnow()
db.session.add(self)
db.session.commit()
return True
except:
db.session.rollback()
raise
def update(self):
"""
Updates object
Returns:
"""
try:
self.updated_at = datetime.datetime.utcnow()
db.session.commit()
except:
db.session.rollback()
raise
class USER(UserMixin, db.Model):
# структура данных пользователей
__tablename__ = 'USERS'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, nullable=False, unique=True)
username = db.Column(db.String(255))
password = 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)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
login = db.Column(db.String, nullable=True, unique=True)
password_hash = db.Column(db.String, nullable=True)
date_user_made = db.Column(db.String, nullable=True)
family = db.Column(db.String, nullable=True)
name = db.Column(db.String, nullable=True)
second_name = db.Column(db.String, nullable=True)
individual_key = db.Column(db.String, nullable=True)
information = db.Column(db.String, nullable=True)
rank = db.Column(db.Integer, nullable=True)
events = db.relationship('EVENTS', backref='author', lazy='dynamic')
role_events = db.relationship('RoleEvents',
backref='RoleEventsUser',
lazy='dynamic')
roles = db.relationship('Role',
secondary='roles_users',
backref=db.backref('users', lazy='dynamic'))
# def __init__(self, login, email, password, date_user_made):
# self.login = login
# self.email = email
# self.password = password
# self.date_user_made = date_user_made
def __repr__(self):
return '%d, %s, %s, %s' % (self.id, self.login, self.email,
self.password_hash)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
