class MsgSession(db.Model):
__tablename__ = 'msg_session'
id = db.Column(db.Integer, primary_key=True)
from_id = db.Column(db.Integer, db.ForeignKey('user.id'))
from_user = db.relationship(User,
primaryjoin='User.id==MsgSession.from_id',
backref=db.backref(
'from_session',
cascade='all,delete-orphan'))
to_id = db.Column(db.Integer, db.ForeignKey('user.id'))
to_user = db.relationship(User,
primaryjoin='User.id==MsgSession.to_id',
backref=db.backref('to_session',
cascade='all,delete-orphan'))
from_read = db.Column(db.Boolean, default=False)
to_read = db.Column(db.Boolean, default=False)
count = db.Column(db.Integer, default=1)
timestamp = db.Column(db.DateTime, index=True)
msg_contents = db.relationship('MsgContent',
backref='session',
lazy='dynamic')
def latest_msg(self):
body = self.msg_contents.filter(
MsgContent.timestamp == self.timestamp).first() #不能使用filter_by
return body.body
def __repr__(self):
return '<Session %r>' % (self.to_user)
class Booking(db.Model):
__tablename__ = 'booking'
id = db.Column(db.Integer, primary_key=True)
is_cancel = db.Column(db.Boolean, default=False)
cancelation_reason = db.Column(db.String(200))
booked_datetime = db.Column(db.DateTime, default=datetime.now())
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
total_price = db.Column(db.Integer)
client_id = db.Column(db.Integer, db.ForeignKey('client.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
activated = db.Column(db.Boolean, default=False)
booked_services = db.relationship('Service', secondary=service_booked)
provided_services = db.relationship('Service', secondary=service_provided)
def fill_booked_services(self, id_list):
"""fills booked_services by given service ids """
for id in id_list:
s = Service.query.get(id)
self.booked_services.append(s)
def fill_provided_services(self, id_list):
"""fills provided_services by given service ids """
for id in id_list:
s = Service.query.get(id)
self.provided_services.append(s)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
posts = db.relationship('Post', backref='author', lazy='dynamic')
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
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)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicons&s={}'.format(
digest, size)
class Projects(db.Model):
__tablename_ = "Projects"
proj_id = db.Column(db.Integer(),
primary_key=True,
autoincrement=True,
nullable=False)
proj_manager = db.Column(db.NVARCHAR(20),
db.ForeignKey("project_managers.manager_code"),
nullable=False)
proj_budget = db.Column(db.Numeric, nullable=False)
proj_name = db.Column(db.NVARCHAR(40), nullable=False)
proj_approval = db.Column(db.Boolean)
proj_deadline = db.Column(db.DateTime)
proj_hours = db.Column(db.Numeric)
proj_client = db.Column(db.NVARCHAR(20),
db.ForeignKey("clients.client_id"))
proj_description = db.Column(db.NVARCHAR(1000))
proj_type = db.Column(db.Integer, db.ForeignKey("project_types.type_id"))
proj_currency = db.Column(db.Integer, db.ForeignKey("currency.curr_id"))
proj_create_date = db.Column(db.Date,
default=datetime.date.today,
nullable=False)
proj_disbs = db.relationship("ProjectDisbursements",
lazy="dynamic",
backref="project")
proj_tasks = db.relationship("ProjectTasks",
lazy="dynamic",
backref="project")
proj_material = db.relationship("WarehouseReqs",
lazy="dynamic",
backref="project")
class Users(db.Model):
""""""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column("username", db.String(64))
display_name = db.Column("DisplayName", db.String(128))
email = db.Column("Email", db.String(128))
# spotify_username = db.Column("spotify_username", db.String(64))
# saved_tracks_id = db.Column(db.Integer, db.ForeignKey("saved_tracks.id"))
# saved_tracks = db.relationship("SavedTracks", backref="users")
# top_artists_id = db.Column(db.Integer, db.ForeignKey("top_artists.id"))
top_artists = db.relationship("TopArtists", backref="users")
# top_tracks_id = db.Column(db.Integer, db.ForeignKey("top_tracks.id"))
top_tracks = db.relationship("TopTracks", backref="users")
# user_playlists_id = db.Column(db.Integer, db.ForeignKey("UserPlaylists.id"))
# user_playlists = db.relationship(
# UserPlaylists, uselist=False, back_populates="users"
# )
# followed_artists_id = db.Column(db.Integer, db.ForeignKey("followed_artists.id"))
# followed_artists = db.relationship("FollowedArtists", backref="users")
def get_user_id(self):
return self.id
def get_username(self):
return self.username
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
avatar = db.Column(db.String(255))
sex = db.Column(db.String(10))
age = db.Column(db.Integer)
account = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
describe = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=datetime.now())
courses = db.relationship("Course", secondary=user_course_table)
modules = db.relationship("Module", secondary=user_module_table)
def to_json(self):
return {
"id": self.id,
"account": self.account,
"name": self.name,
"avatar": self.avatar,
"sex": self.sex,
"age": self.age,
"describe": self.describe,
"created_at": self.created_at
}
class Course(db.Model):
__tablename__ = "courses"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
admin_id = db.Column(db.Integer, db.ForeignKey('admins.id'))
content = db.Column(db.Text)
videos = db.Column(db.Text)
type = db.Column(db.Integer)
module_id = db.Column(db.Integer, db.ForeignKey('modules.id'))
cover = db.Column(db.String(255))
collect_num = db.Column(db.Integer, default=0)
view_num = db.Column(db.Integer, default=0)
score = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime, default=datetime.now())
module = db.relationship('Module')
admin = db.relationship("Admin")
users = db.relationship("User", secondary=user_course_table)
def to_json(self):
return {
"id": self.id,
"name": self.name,
"admin": self.admin.to_json(),
"content": self.content,
"videos": self.videos,
"type": self.type,
"module": self.module.name,
"score": self.score,
"view_num": self.view_num,
"collect_num": self.collect_num,
"created_at": self.created_at,
"cover": self.cover
}
class Scores(db.Model):
__tablename__ = "scores"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
score = db.Column(db.Integer)
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
user = db.relationship("User")
course = db.relationship("Course")
class Class(db.Model):
id = db.Column(db.Integer, primary_key=True)
class_id = db.Column(db.String(7), unique=True, nullable=False)
class_name = db.Column(db.String(255), unique=True, nullable=False)
schedule = db.relationship('Schedule', backref='schedule_c', lazy=True)
student = db.relationship('Profile_Student',
backref='student_c',
lazy=True)
def __repr__(self) -> str:
return '<Role %s>' % self.class_id
class BackupInstance(db.Model):
__tablename__ = 'backup_instance'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
server_id = db.Column(db.String(255), nullable=False)
backup_type_id = db.Column(db.Integer, db.ForeignKey('backup_type.id'), nullable=False)
backup_type = db.relationship('BackupType', backref=db.backref('backupinstances', lazy='dynamic'))
business_id = db.Column(db.Integer, db.ForeignKey('business.id'), nullable=False)
business = db.relationship('Business', backref=db.backref('backupinstances', lazy='dynamic'))
instance = db.Column(db.Integer, nullable=False)
class User(db.Model):
__tablename__ = 'user'
public_id = db.Column(db.String(50), unique=True,primary_key = True)
name = db.Column(db.String(50))
email = db.Column(db.String(50))
password = db.Column(db.String(80))
admin = db.Column(db.Boolean)
##Relationships --
goals = db.relationship('Goal', backref='owner', lazy='dynamic') ## One to Many Relationship
reminders = db.relationship('Reminder', backref = 'owner',lazy = "dynamic") ## One to Many relationship
categorys = db.relationship('Category',backref = 'owner',lazy = "dynamic") ## One to Many relationship
transactions = db.relationship('Transaction',backref ='owner',lazy = "dynamic")
class Nickname(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True)
article = db.relationship('Article', backref='nick', lazy='dynamic')
n_comment = db.relationship('Comment', backref='n_com', lazy='dynamic')
admin = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class TopArtistsArtistsAssociation(db.Model):
""""""
__tablename__ = "top_artists_artists_association"
top_artists_id = db.Column(db.Integer,
db.ForeignKey("top_artists.id"),
primary_key=True)
artists_id = db.Column(db.Integer,
db.ForeignKey("artists.id"),
primary_key=True)
top_artists = db.relationship("TopArtists")
artists = db.relationship("Artists")
rank = db.Column(db.Integer, default=-1)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
tasks = db.relationship('Task', backref='user', lazy='dynamic')
habits = db.relationship('Habit', backref='user', lazy='dynamic')
def get_id(self):
return str(self.id)
def __repr__(self):
return '<User {}>'.format(self.username)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
followed = db.relationship(
'User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic',
)
def __repr__(self):
return '<User {}>'.format(self.username)
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)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(7), unique=True, nullable=False)
user_name = db.Column(db.String(255), nullable=False)
user_role = db.Column(db.String(7),
db.ForeignKey('role.role_id', onupdate='CASCADE'),
nullable=False)
password = db.Column(db.String(255), nullable=False)
subject = db.relationship('Subject', backref='teacher', lazy=True)
profile_employee = db.relationship('Profile_Employee',
backref='employee',
lazy=True)
def __repr__(self) -> str:
return '<User %s>' % self.user_name
class Role(db.Model):
"""
Roles are an aggregate of permissions
"""
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(64), unique=True)
description = db.Column(db.String(280))
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
def __repr__(self):
return '<Role: {}> \n'.format(self.name)
@staticmethod
def insert_roles():
roles = {
'Customer': (Permission.BUY, True),
'Moderator': (Permission.BUY |
Permission.WRITE_BLOGS |
Permission.MODERATE_CONTENT, False),
'Administrator': (0xff, False)
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.permissions = roles[r][0]
role.default = roles[r][1]
db.session.add(role)
db.session.commit()
class Role(db.Model):
role_id = db.Column(db.String(7), primary_key=True)
role_name = db.Column(db.String(255), nullable=False)
user = db.relationship('User', backref='role', lazy=True)
def __repr__(self) -> str:
return '<Role %s>' % self.role_name
class Category(db.Model):
__tablename__ = 'category'
type = db.Column(db.String(30),
unique=True,
primary_key=True,
nullable=False)
devices = db.relationship('Device', backref='category', lazy='dynamic')
class Comment(db.Model):
__tablename__ = "comments"
id = db.Column(db.Integer, primary_key=True)
from_user_id = db.Column(db.Integer)
from_user_type = db.Column(db.Integer)
to_user_id = db.Column(db.Integer)
to_user_type = db.Column(db.Integer)
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
content = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=datetime.now())
course = db.relationship("Course")
def to_json(self):
if self.from_user_type == 1:
from_user = User.query.get(self.from_user_id).to_json()
else:
from_user = Admin.query.get(self.from_user_id).to_json()
if self.to_user_type == 1:
to_user = User.query.get(self.to_user_id).to_json()
else:
to_user = Admin.query.get(self.to_user_id).to_json()
return {
'id': self.id,
"from_user": from_user,
"to_user": to_user,
"content": self.content,
"course": self.course.to_json(),
"created_at": self.created_at
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
password = db.Column(db.String(64))
role = db.Column(db.SmallInteger, default=ROLE_USER)
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User %r>' % (self.username)
@classmethod
def login_check(cls, username, password):
user = cls.query.filter(
db.and_(User.username == username,
User.password == password)).first()
if not user:
return None
return user
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
article_id = db.Column(db.Integer, db.ForeignKey('post.id')) # 评论文章id
content = db.Column(db.String(100), nullable=False)
time = db.Column(db.DateTime,
default=datetime.strptime(
datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'%Y-%m-%d %H:%M:%S'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 用户id
to_user = db.Column(db.Integer) # 回复的用户,无则None
to_id = db.Column(db.Integer) # 回复目标id，无回复则None #
c_post = db.relationship('Post',
backref=db.backref('comments',
order_by=id.desc()))
c_user = db.relationship('User', backref=db.backref('comments'))
class Student(UserMixin, db.Model):
__tablename__ = 'students'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
Class = db.Column(db.Unicode)
password_hash = db.Column(db.String(128))
grades = db.relationship('Grade', backref='student', lazy='dynamic')
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@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 __init__(self, id, name, Class, password=app.config['DEFAULT_PASSWD']):
self.id = id
self.name = name
self.Class = Class
self.password_hash = password
@staticmethod
def add_stu1():
stu1 = Student(1234567890, 'stu1', 123)
db.session.add(stu1)
db.session.commit()
def __repr__(self):
return '<Student %r>' % self.id
class Student(db.Model, UserMixin):
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String(25),nullable=False,unique=True)
email = db.Column(db.String(30),nullable=False,unique=True)
password = db.Column(db.String(100),nullable=False)
gender = db.Column(db.String(5))
birthday = db.Column(db.Date)
phone = db.Column(db.BigInteger(),nullable=False,unique=True)
image_file = db.Column(db.String(64),nullable=False,default='default.jpg')
events = db.relationship('Event',secondary='student_events',backref='student',lazy='dynamic')
def __repr__(self):
return '<User %r>' % self.username
def get_reset_token(self,expires_after_secs=1800):
s = Serializer(app.config['SECRET_KEY'],expires_after_secs)
return s.dumps({'user_id':self.id}).decode('utf-8')
@staticmethod
def get_verify_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except itsdangerous.SignatureExpired:
return None
return Student.query.get(user_id)
class Module(db.Model):
__tablename__ = "modules"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
courses = db.relationship("Course")
def to_json(self):
return {"id": self.id, "name": self.name}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
uname = db.Column(db.String(30), nullable=False, unique=True)
email = db.Column(db.String(40), unique=True, nullable=False)
password_hash = db.Column(db.String, nullable=False)
tasks = db.relationship("Task", backref="author", lazy=True)
def __repr__(self):
return f"User('{self.uname}','{self.email}')"
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
created = db.Column(db.TIMESTAMP,
server_default=db.text('CURRENT_TIMESTAMP'))
title = db.Column(db.Text, nullable=False)
body = db.Column(db.Text, nullable=False)
author = db.relationship('User', backref="post")
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
pass_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __repr__(self):
return '<User {} with {}>'.format(self.username, self.email)
class WarehouseUnits(db.Model):
__tablename_ = "warehouse_units"
units_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
units_name = db.Column(db.VARCHAR(40), nullable=False)
units_abbr = db.Column(db.NVARCHAR(15), nullable=False)
product = db.relationship("WarehouseProducts",
lazy="dynamic",
backref="unitnames")
class Info(db.Model):
id = db.Column(db.Integer, primary_key=True)
url_id = db.Column(db.Integer, db.ForeignKey('url.id'))
word_id = db.Column(db.Integer, db.ForeignKey('word.id'))
count = db.Column(db.Float)
url = db.relationship(Url, backref='infos')
word = db.relationship(Word, backref='infos')
def __init__(self, url=None, word=None, count=1):
if url is not None:
self.url = url
if word is not None:
self.word = word
self.count = count
def __unicode__(self):
return unicode(self.id)
