class Followrelationship(db.Model):
__tablename__ = 'follow'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
follower_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
followed_id = db.Column(db.Integer, db.ForeignKey('employee.id'))
follower = db.relationship('Customer', backref=db.backref('follower'))
followed = db.relationship('Employee', backref=db.backref('followed'))
class User(db.Model, UserMixin):
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())
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{'reset_password': self.id, 'exp': time() + expires_in},
app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class Entry(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
content = db.Column(db.Text)
content_html = db.Column(db.Text)
fragment = db.Column(db.Text) #内容片段, 用于主页显示
status = db.Column(db.Integer, default=1) #完成：1, 失败0, 草稿:-1 （暂时无用）
create_time = db.Column(db.DateTime, index=True, default=datetime.now())
modified_time = db.Column(db.DateTime, default=datetime.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category = db.relationship('Category', backref=db.backref('entries', lazy='dynamic'), lazy='select')
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
tag = db.relationship('Tag', secondary=tag_entry, backref=db.backref('entries', lazy='dynamic'))
view_count = db.Column(db.Integer, default=0)
@staticmethod
def on_changed_content(target, value, oldvalue, initator):
if CONTENT_FORMAT == 'html':
target.content_html = value
else:
target.content_html = md2html(text=value)
def __repr__(self):
return '<Entry %r>' % self.title
def __unicode__(self):
return self.title
class AnswerQuestion(db.Model):
__tablename__ = 'answer_question'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.Text, nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey('employee.id'))
answer_question_id = db.Column(db.Integer, db.ForeignKey('question.id'))
author = db.relationship('Employee', backref=db.backref('realanswer'))
question = db.relationship('Question',
backref=db.backref('questionAnswer'))
class Customer(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))
phone = db.Column(db.Integer, index=True)
firstname = db.Column(db.String(64), index=True)
lastname = db.Column(db.String(64), index=True)
pets = db.relationship('Pet', backref='owner', lazy='dynamic')
appointments = db.relationship('Appointment', backref='customer', lazy='dynamic')
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
class NewAppointment(db.Model):
id = db.Column(db.Integer, primary_key=True)
applicant = db.Column(db.String(20), index=True, nullable=False)
date = db.Column(db.String(20), index=True, nullable=False)
appoint_time = db.Column(db.Integer, index=True, nullable=False)
petType = db.Column(db.Integer, index=True, nullable=False)
petName = db.Column(db.String(20), index=True, nullable=False)
doctor = db.Column(db.Integer, index=True, nullable=False)
phoneNo = db.Column(db.String(20), index=True, nullable=False)
comment = db.Column(db.String(20), default="")
condition = db.Column(db.Integer, index=True, default=1, nullable=False)
op_date = db.Column(db.String(20), index=True)
op_time = db.Column(db.Integer, index=True)
app_type = db.Column(db.Integer, index=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
cus_appoint = db.relationship('Customer', backref=db.backref('Customer'))
def to_dict(self):
result = {}
for key in self.__mapper__.c.keys():
if getattr(self, key) is not None:
result[key] = str(getattr(self, key))
else:
result[key] = getattr(self, key)
return result
def to_json(all_vendors):
v = [ven.to_dict() for ven in all_vendors]
return v
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class UserModel(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(256), nullable=False)
first_name = db.Column(db.String(20), nullable=False)
last_name = db.Column(db.String(20), nullable=False)
dob = db.Column(db.DateTime, nullable=False)
gender = db.Column(db.String, nullable=False)
mobile_no = db.Column(db.String(10), unique=True, nullable=False)
profile_pic = db.Column(db.String, default='default_profile.jpg')
blogs = db.relationship('BlogModel', backref='creator', lazy=True)
def __init__(self, email, password, first_name, last_name, mobile_no,
gender, dob, profile_pic):
self.username = str(email).split('@')[0]
self.email = email
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
self.first_name = first_name
self.last_name = last_name
self.mobile_no = mobile_no
self.gender = gender
self.dob = dob
self.profile_pic = profile_pic
def __repr__(self):
return f"Hello I am {self.username}"
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
class Question(db.Model):
__tablename__ = 'question'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question_title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
author_name = db.Column(db.String(64), db.ForeignKey('customer.username'))
author = db.relationship('Customer', backref=db.backref('realquestions'))
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 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())
def __repr__(self):
return '<User {}>'.format(self.username)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(150), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return 'User name is %r' % self.username
class Entry(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
content = db.Column(db.Text)
fragment = db.Column(db.Text) #内容片段, 用于主页显示
status = db.Column(db.Integer, default=1) #完成：1, 失败0, 草稿:-1 （暂时无用）
create_time = db.Column(db.DateTime, index=True, default=datetime.now())
modified_time = db.Column(db.DateTime, default=datetime.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category = db.relationship('Category', backref=db.backref('entries', lazy='dynamic'), lazy='select')
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
tag = db.relationship('Tag', secondary=tag_entry, backref=db.backref('entries', lazy='dynamic'))
view_count = db.Column(db.Integer, default=0)
def __repr__(self):
return '<Entry %r>' % self.title
def __unicode__(self):
return self.title
class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64))
post_body = db.Column(db.String(1024))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User')
create_date = db.Column(db.DateTime, default=datetime.utcnow)
yn = db.Column(db.SmallInteger, default=1)
def __repr__(self):
"<post: {}>".format(self.title)
class BlogModel(db.Model):
__tablename__ = 'blog'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True, nullable=False)
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
date_of_creation = db.Column(db.DateTime, default=datetime.now)
is_active = db.Column(db.Boolean, default=False)
posts = db.relationship('PostModel', backref='blog', lazy=True)
def __repr__(self):
return f"Blog : {self.name}"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(18), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default="default.jpg")
password = db.Column(db.String(60), nullable=False)
posts = db.relationship("Post", backref="author", lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Pet(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True)
type = db.Column(db.String(64), index=True)
old = db.Column(db.Integer, index=True)
gender = db.Column(db.String(64), index=True)
customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
appointments = db.relationship('Appointment', backref='pet', lazy='dynamic')
def __repr__(self):
return '<Pet {}>'.format(self.name)
class NewAppointment(db.Model):
id = db.Column(db.Integer, primary_key=True)
applicant = db.Column(db.String(20), index=True, nullable=False)
date = db.Column(db.DateTime, index=True, nullable=False)
petType = db.Column(db.Integer, index=True, nullable=False)
doctor = db.Column(db.Integer, index=True, nullable=False)
phoneNo = db.Column(db.String(20), index=True, nullable=False)
comment = db.Column(db.String, default="")
user_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
cus_appoint = db.relationship('Customer', backref=db.backref('Customer'))
def __repr__(self):
return '<User {}>'.format(self.username)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return "User('{0}', '{1}', '{2}')".format(self.username, self.email,
self.image_file,
self.password)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(80), unique=True)
nickname = db.Column(db.String(80), unique=True)
password = db.Column(db.String(64), unique=True)
email = db.Column(db.String(120), unique=True)
role = db.Column(db.SmallInteger, default=ROLE_ADMIN)
entry = db.relationship('Entry', backref='author', lazy='dynamic')
about_me = db.Column(db.String(250))
last_seen = db.Column(db.DateTime)
# Flask-Login integration
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 get_id(self):
return unicode(self.id)
# #防止昵称相同
# @staticmethod
# def make_unique_nickname(nickname):
# if User.query.filter_by(nickname=nickname).first() == None:
# return nickname
# virsion = 2
# while True:
# new_nickname = nickname + str(virsion)
# if User.query.filter_by(nickname=new_nickname).first() == None:
# break
# virsion += 1
# return new_nickname
def __repr__(self):
return '<User %r>' % self.nickname
def __unicode__(self):
return self.nickname
class BlogPost(db.Model):
users = db.relationship(User)
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
title = db.Column(db.String(140), nullable=False)
text = db.Column(db.Text, nullable=False)
def __init__(self, title, text, user_id):
self.title = title
self.text = text
self.user_id =user_id
def __repr__(self):
return f"Post Id: {self.id} --- Date: {self.date} --- Title: {self.title}"
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key = True)
profile_image = db.Column(db.String(20), nullable=False, default='default_profile.png')
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
# This connects BlogPosts to a User Author.
posts = db.relationship('BlogPost', backref='author', lazy=True)
is_admin = db.Column(db.Boolean,default=False)
def __init__(self, email, username, password,is_admin):
self.email = email
self.username = username
self.password_hash = generate_password_hash(password)
self.is_admin = is_admin
def check_password(self,password):
return check_password_hash(self.password_hash,password)
def __repr__(self):
return f"UserName: {self.username}"
class User(UserMixin, db.Model):
__tablename__ = 'users'
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')
def __repr__(self):
return '<User {}>'.format(self.username)
def to_json(self):
json_user = {
'username': self.username,
}
return json_user
def setPassword(self, password):
self.password_hash = generate_password_hash(password)
def checkPassword(self, password):
return check_password_hash(self.password_hash, password)
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(64), 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.now)
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)
# To get the image of specified size from Gravatar Service
def avatar(self, size):
hash_val = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
hash_val, size)
