class Payment(base.BaseModel):
__tablename__ = 'payments'
id = db.Column(db.Integer, primary_key=True)
item = db.Column(db.String())
amount = db.Column(db.String())
paid_at = db.Column(db.String())
paid = db.Column(db.Boolean())
approved = db.Column(db.Boolean())
assigned_user = db.Column(db.Integer())
receipt_id = db.Column(db.Integer())
assigned_by = db.Column(db.Integer())
assigned_at = db.Column(db.DateTime())
def __init__(self, item, amount, paid_at, paid, approved, assigned_user, receipt_id, assigned_by, assigned_at):
self.item = item
self.amount = amount
self.paid_at = paid_at
self.paid = paid
self.approved = approved
self.assigned_user = assigned_user
self.receipt_id = receipt_id
self.assigned_by = assigned_by
self.assigned_at = assigned_at
def __repr__(self):
return f"<Item {self.item}>"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
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'))
def __str__(self):
return self.email
# Create customized model view class
class MyModelView(sqla.ModelView):
def is_accessible(self):
return (current_user.is_active and current_user.is_authenticated
and current_user.has_role('superuser'))
def _handle_view(self, name, **kwargs):
"""
Override builtin _handle_view in order to redirect users when a view is not accessible.
"""
if not self.is_accessible():
if current_user.is_authenticated:
# permission denied
abort(403)
else:
# login
return redirect(url_for('security.login', next=request.url))
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password_hash = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password_hash = bcrypt.generate_password_hash(
password, current_app.config.get("BCRYPT_LOG_ROUNDS")).decode()
def to_json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"active": self.active,
}
class CustomList(db.Model):
query_class = CustomListQUery
search_vector = db.Column(TSVectorType('name'))
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(64))
owner_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
items = relationship('CustomListItem',
cascade='all, delete-orphan',
backref='list')
creation_ts = db.Column(db.DateTime(), default=datetime.utcnow)
description = db.Column(db.String(256))
private = db.Column(db.Boolean(), default=False)
def get_list_details(self):
ret = {
'name': self.name,
'list_id': self.id,
'creation_ts': self.creation_ts,
'private': self.private,
'items': []
}
for item in self.items:
ret['items'].append({
'title': item.movie.title,
'ordering': item.ordering,
'notes': item.notes
})
ret['num_items'] = len(ret['items'])
return ret
class Comment(BaseModel, Model):
__tablename__ = 'comment'
user_id = Column(db.ForeignKey('user.id'), comment='用户id')
content = Column(db.String(200), comment='评论内容')
article_id = Column(db.ForeignKey('article.id'), comment='所属内容ID')
father_id = Column(db.ForeignKey('comment.id'), comment='父评论ID')
valid = Column(db.Boolean(), comment='有效性')
class Plant(BaseModel, Model):
__tablename__ = 'plant'
name = Column(db.String(40), comment='名称')
category = Column(db.String(40), comment='分类')
needs = Column(db.String(40), comment='成长条件')
active_flag = Column(db.Boolean(), server_default=db.text("True"), comment="是否启用，True启用 False不启用", index=True)
seed_unit = Column(db.String(4), comment='种子单位')
class Character(db.Model):
__tablename__ = 'characters'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), index=True)
desc = db.Column(db.String())
race = db.Column(db.String())
player_character = db.Column(db.Boolean())
char_class = db.Column(db.String())
def __init__(self, name, desc, race, char_class, player_character):
self.name = name
self.desc = desc
self.race = race
self.char_class = char_class
self.player_character = player_character
def __repr__(self):
return '<name {}>'.format(self.name)
def serialize(self):
return {
'id': self.id,
'name': self.name,
'desc': self.desc,
'race': self.race,
'char_class': self.char_class,
'player_character': self.player_character
}
class SessionModel(db.Model):
__tablename__: str = "session"
uuid: db.Column = db.Column(db.String(32), primary_key=True, unique=True)
administrator: db.Column = db.Column(db.String(255),
ForeignKey('administrator.uuid'))
broken: db.Column = db.Column(db.Boolean(), nullable=False)
@property
def serialize(self):
dict = {
"uuid": self.uuid,
"administrator": self.administrator,
"broken": self.broken,
}
return dict
@staticmethod
def create(administrator) -> "SessionModel":
uuid = str(uuid4()).replace('-', '')
session = SessionModel(uuid=uuid,
administrator=administrator.uuid,
broken=False)
db.session.add(session)
db.session.commit()
return session
class NoteModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
note = db.Column(db.String(300), unique=False, nullable=False)
date = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey(UserModel.id))
private = db.Column(db.Boolean(),
default=True,
server_default="true",
nullable=False)
archive = db.Column(db.Boolean(),
default=False,
server_default="false",
nullable=False)
tags = db.relationship(TagModel,
secondary=tags,
lazy='subquery',
backref=db.backref('notes', lazy=True))
@classmethod
def get_all_notes(cls, author, archive):
if archive == "all":
return NoteModel.query.filter_by(author_id=author.id).all()
if archive == "no_archive":
return NoteModel.query.filter_by(author_id=author.id,
archive=False).all()
if archive == "archive":
return NoteModel.query.filter_by(author_id=author.id,
archive=True).all()
@classmethod
def get_all_public_notes(cls):
return NoteModel.query.filter_by(private=False, archive=False).all()
@classmethod
def get_notes_filtered_by_tags(cls, tag_name):
return NoteModel.query.filter(NoteModel.tags.any(name=tag_name),
NoteModel.archive == False).all()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Article(BaseModel, Model):
__tablename__ = 'article'
user_id = Column(db.ForeignKey('user.id'), comment='发布者id')
title = Column(db.String(50), comment='标题')
content = Column(db.String(5000), comment='内容')
category = Column(db.String(20), comment='分类')
valid = Column(db.Boolean(), comment='有效性')
clicks = Column(db.Integer(), comment='点击量')
likes = Column(db.Integer(), comment='点赞量')
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password_hash = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password_hash = bcrypt.generate_password_hash(
password, current_app.config.get("BCRYPT_LOG_ROUNDS")).decode()
def to_json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"active": self.active,
}
def encode_auth_token(self):
try:
payload = {
"exp":
datetime.utcnow() + timedelta(
days=current_app.config.get("TOKEN_EXPIRATION_DAYS"),
seconds=current_app.config.get("TOKEN_EXPIRATION_SECONDS"),
),
"iat":
datetime.utcnow(),
"sub":
self.id,
}
return jwt.encode(
payload,
current_app.config.get("SECRET_KEY"),
algorithm="HS256",
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(auth_token,
current_app.config.get("SECRET_KEY"))
return payload["sub"]
except jwt.ExpiredSignatureError:
return "Signature expired"
except jwt.InvalidTokenError:
return "Invalid token"
class FlicksListItem(db.Model):
id = db.Column(db.Integer, primary_key=True)
movie = db.relationship('Movie')
movie_id = db.Column(db.Integer(), db.ForeignKey('movie.id'))
list_id = db.Column(db.Integer(), db.ForeignKey('flicks_list.id'))
notes = db.Column(db.String(64))
completed = db.Column(db.Boolean(), default=False)
rating = db.Column(db.Integer())
completion_date = db.Column(db.Date())
ordering = db.Column(db.Integer())
class HashToken(db.Model):
"""Table for hash tokens."""
__tablename__ = "hashtoken"
htk_id = db.Column(db.String(255), primary_key=True, nullable=False)
htk_tsk_id = db.Column(db.Integer(), db.ForeignKey("task.tsk_id"))
htk_usr_id = db.Column(db.Integer(), db.ForeignKey("user.usr_id"))
htk_locked = db.Column(db.Boolean(), nullable=False, server_default="0")
htk_auth = db.Column(db.String(64))
htk_pin = db.Column(db.String(255))
htk_creation_date = db.Column(db.DateTime())
class UserPlant(BaseModel, Model):
__tablename__ = 'user_plant'
plant_id = Column(db.ForeignKey('plant.id'), comment="植物id")
user_id = Column(db.ForeignKey('user.id'), comment="用户id")
active_flag = Column(db.Boolean(), server_default=db.text("True"), comment="是否启用，True启用 False不启用", index=True)
water = Column(db.Integer(), comment='水分')
fertilizer = Column(db.Integer(), comment='肥料')
pesticide = Column(db.Integer(), comment='药')
price = Column(db.Numeric(4, 2), comment='价值')
harvest_at = Column(db.Date(), comment='预计收获时间')
status = Column(db.Enum(PlantStatus), comment='状态')
image = Column(db.String(1024), comment='图片')
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
username = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
class GroupMembers(base.BaseModel):
__tablename__ = 'group_members'
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer())
active = db.Column(db.Boolean())
user_id = db.Column(db.Integer())
def __init__(self, group_id, active, user_id):
self.group_id = group_id
self.active = active
self.user_id = user_id
def __repr__(self):
return f"<Group ID: {self.group_id}>"
class Group(base.BaseModel):
__tablename__ = 'groups'
id = db.Column(db.Integer, primary_key=True)
group_name = db.Column(db.String())
active = db.Column(db.Boolean())
created_by = db.Column(db.String())
def __init__(self, groupname, active, createdby):
self.group_name = groupname
self.active = active
self.created_by = createdby
def __repr__(self):
return f"<Group: {self.group_name}>"
class Customer(db.Model):
"""Table fo customers"""
__tablename__ = "customer"
cus_id = db.Column(db.Integer, primary_key=True)
cus_title = db.Column(db.String(64), index=True, nullable=True)
cus_first_name = db.Column(db.String(255), index=True, nullable=True)
cus_last_name = db.Column(db.String(255), index=True, nullable=True)
cus_email = db.Column(db.String(255), index=True, nullable=True)
cus_phone_no = db.Column(db.String(255), index=True, nullable=True)
cus_street = db.Column(db.String(255), index=True, nullable=True)
cus_house_number = db.Column(db.String(64), index=True, nullable=True)
cus_post_code = db.Column(db.String(64), index=True, nullable=True)
cus_awo_member = db.Column(db.Boolean(),
nullable=False,
server_default="0")
tasks = db.relationship('Task', backref='customer', lazy=True)
class User(base.BaseModel):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String())
password = db.Column(db.String())
active = db.Column(db.Boolean())
first_name = db.Column(db.String())
last_name = db.Column(db.String())
def __init__(self, username, password, active, first_name, last_name):
self.username = username
self.password = password
self.active = active
self.first_name = first_name
self.last_name = last_name
def __repr__(self):
return f"<User {self.username}>"
class NoteModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey(UserModel.id))
text = db.Column(db.String(255), unique=False, nullable=False)
private = db.Column(db.Boolean(),
default=True,
server_default="true",
nullable=False)
tags = db.relationship(TagModel,
secondary=tags,
lazy='subquery',
backref=db.backref('notes', lazy=True))
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime,
default=datetime.datetime.now(),
nullable=False)
def __init__(self, username, email):
self.username = username
self.email = email
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active
}
class TicketModel(db.Model):
__tablename__: str = "ticket"
uuid: db.Column = db.Column(db.String(32), primary_key=True, unique=True)
customer: db.Column = db.Column(db.String(32), ForeignKey('customer.uuid'))
paid: db.Column = db.Column(db.Boolean(), nullable=False)
seat_id: db.Column = db.Column(db.String(32), ForeignKey('seat.uuid'))
meeting_id: db.Column = db.Column(db.String(32),
ForeignKey('meeting.uuid'))
price_id: db.Column = db.Column(db.String(32), ForeignKey('price.uuid'))
@property
def serialize(self):
dict = self.__dict__
key = '_sa_instance_state'
if key in dict:
del dict[key]
return dict
@staticmethod
def create(customer, meeting, seat, price):
uuid = str(uuid4()).replace('-', '')
ticket: TicketModel = TicketModel(uuid=uuid,
customer=customer.uuid,
paid=False,
seat_id=seat.uuid,
meeting_id=meeting.uuid,
price_id=price.uuid)
db.session.add(ticket)
db.session.commit()
return ticket
class User(db.Model):
query_class = UserQuery
search_vector = db.Column(TSVectorType('username'))
# Account Specific
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
email = db.Column(db.String(128), unique=True)
pw_hash = db.Column(db.String(128), nullable=False)
verified = db.Column(db.Boolean(), default=False)
# Profile Specific
fav_genre = db.Column(db.String(64))
join_date = db.Column(db.Date(), default=date.today)
last_online = db.Column(db.DateTime(), default=datetime.utcnow)
gender = db.Column(db.String(64))
location = db.Column(db.String(64))
website = db.Column(db.String(64))
about = db.Column(db.String(256))
profile_views = db.Column(db.Integer(), default=0)
friends = db.relationship('Friendship',
primaryjoin=id == Friendship.user_id,
lazy='dynamic') # M:M
profile_comments = db.relationship('Comment',
foreign_keys='Comment.host_id') # 1:M
posted_comments = db.relationship('Comment',
foreign_keys='Comment.author_id',
backref='author') # 1:M
flicks_list = db.relationship('FlicksList', backref='owner',
uselist=False) # 1:1
favourites = db.relationship('Favourite') # M:M
custom_lists = db.relationship('CustomList', backref='owner') # 1:M
recommendations = db.relationship('Recommendation',
backref='author') # 1:M
reviews = db.relationship('Review', backref='author') # 1:M
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.flicks_list = FlicksList(name='Flickslist')
@classmethod
def verify_confirmation_token(cls, token):
serializer = Serializer(current_app.config['SECRET_KEY'])
try:
data = serializer.loads(token)
user_id = data.get('user_id_confirm')
except:
return None
return User.query.get(user_id)
@classmethod
def verify_reset_password_token(cls, token):
serializer = Serializer(current_app.config['SECRET_KEY'])
try:
data = serializer.loads(token)
user_id = data.get('user_id_reset_pass')
except:
return None
return User.query.get(user_id)
def set_password(self, password):
self.pw_hash = bcrypt.generate_password_hash(password).decode('utf-8')
def verify_password(self, password):
return bcrypt.check_password_hash(self.pw_hash, password)
def generate_confirm_token(self):
serializer = Serializer(
current_app.config['SECRET_KEY'],
expires_in=current_app.config['JWT_CONFIRM_TOKEN_EXPIRES'])
return serializer.dumps({'user_id_confirm': self.id}).decode('utf-8')
def generate_reset_password_token(self):
serializer = Serializer(
current_app.config['SECRET_KEY'],
expires_in=current_app.config['JWT_RESET_PASS_TOKEN_EXPIRES'])
return serializer.dumps({
'user_id_reset_pass': self.id
}).decode('utf-8')
def add_friend(self, friend, active=0):
self.friends.append(
Friendship(user_id=self.id, friend_id=friend.id, active=active))
db.session.commit()
def remove_friend(self, friend):
self.friends.remove(friend)
friend.friends.remove(self)
db.session.commit()
class ArticleCatalog(BaseModel, Model):
__tablename__ = 'article_catalog'
name = Column(db.String(50), comment='分类名称')
valid = Column(db.Boolean(), comment='有效性')
class NoteModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
note = db.Column(db.String(300), unique=False, nullable=False)
date = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey(UserModel.id))
private = db.Column(db.Boolean(),
default=True,
server_default="true",
nullable=False)
archive = db.Column(db.Boolean(),
default=False,
server_default="false",
nullable=False)
tags = db.relationship(TagModel,
secondary=tags,
lazy='subquery',
backref=db.backref('notes', lazy=True))
@classmethod
def get_all_notes(cls, author, archive):
"""
Фильтрует заметки по признаку "архива"
:param author: автор заметки
:param archive: флаг "архива"
:return: заметки
"""
if archive == "all":
return NoteModel.query.filter_by(author_id=author.id).all()
if archive == "no_archive":
return NoteModel.query.filter_by(author_id=author.id,
archive=False).all()
if archive == "archive":
return NoteModel.query.filter_by(author_id=author.id,
archive=True).all()
@classmethod
def get_all_public_notes(cls):
"""
Фильтрует заметки по признаку "публичности"
:return: публичные заметки
"""
return NoteModel.query.filter_by(private=False, archive=False).all()
@classmethod
def get_notes_filtered_by_tags(cls, tag_name):
"""
Фильтрует заметки по признакам
:param tag_name: имя тэга
:return: заметки
"""
return NoteModel.query.filter(NoteModel.tags.any(name=tag_name),
NoteModel.archive == False).all()
def save(self):
"""
Сохраняет заметку в БД
"""
db.session.add(self)
db.session.commit()
def delete(self):
"""
Удаляет заметку из БД
"""
db.session.delete(self)
db.session.commit()