class Region(db.Model):
__tablename__ = 'region'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255))
slug = db.Column(db.String(255), unique=True)
created = db.Column(db.DateTime())
updated = db.Column(db.DateTime())
active = db.Column(db.Integer())
osm_id = db.Column(db.Integer())
geo_json = db.Column(db.Text())
rgs = db.Column(db.String(255))
region_level = db.Column(db.Integer())
postalcode = db.Column(db.String(255))
lat = db.Column(db.Numeric(precision=10,scale=7))
lon = db.Column(db.Numeric(precision=10,scale=7))
region_parent_id = db.Column(db.Integer, db.ForeignKey('region.id'))
region_parent = db.relationship("Region", backref="region_children", remote_side=[id])
service_sites = db.relationship("ServiceSite", backref="region", lazy='dynamic')
# hosts as defined in Host
def __init__(self):
pass
def __repr__(self):
return '<Hoster %r>' % self.name
class Advertisement(db.Model):
id = db.Column(db.Integer, primary_key=True)
companydetail_id = db.Column(db.Integer,
db.ForeignKey('companydetail.id'),
nullable=False)
date_posted = db.Column(db.Date, nullable=False, default=date.today())
deadline = db.Column(db.Date,
nullable=False,
default=date.today() + relativedelta(months=+1))
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.String(800), nullable=False)
keywords = db.relationship('Keyword',
secondary=advertisement_keyword,
lazy='subquery',
backref=db.backref('advertisements', lazy=True))
users = db.relationship('User',
secondary=advertisement_users,
lazy='subquery',
backref=db.backref('advertisements', lazy=True))
responses = db.relationship('Response', backref='advertisement')
def __repr__(self): #alihan
return f"Advertisement('{self.id}', '{self.title}')"
class Companydetail(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False,
unique=True)
name = db.Column(db.String(150), nullable=False)
description = db.Column(db.String(800), nullable=False)
address = db.Column(db.String(800), nullable=False)
website = db.Column(db.String(180))
github = db.Column(db.String(180))
linkedin = db.Column(db.String(180))
numberofworkers = db.Column(db.Integer)
advertisements = db.relationship('Advertisement',
backref='company_detail',
lazy=True)
img = db.Column(db.Text, nullable=True)
imgname = db.Column(db.Text, nullable=True)
mimetype = db.Column(db.Text, nullable=True)
keywords = db.relationship('Keyword',
secondary=companydetail_keyword,
lazy='subquery',
backref=db.backref('companydetails', lazy=True))
interests = db.relationship('Interestarea',
secondary=companydetail_interestarea,
lazy='subquery',
backref=db.backref('companydetails',
lazy=True))
def __repr__(self):
return f"Companydetail('{self.id}', '{self.name}')"
class Order(db.Model, Repopulatable):
id = db.Column(db.Integer, primary_key=True)
platform_order_id = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", backref=db.backref("orders"))
user_legacy_id = db.Column(db.Integer, db.ForeignKey('user_legacy.id'))
user_legacy = db.relationship("UserLegacy", backref=db.backref("orders"))
products = db.relationship('Product', secondary=order_products_table,
backref=db.backref('orders', lazy='dynamic'))
shop_id = db.Column(db.Integer, db.ForeignKey('shop.id'))
shop = db.relationship("Shop", backref=db.backref("orders"))
browser_ip = db.Column(db.String)
delivery_tracking_number = db.Column(db.String)
discount = db.Column(db.String)
status = db.Column(db.String,
default=Constants.ORDER_STATUS_PURCHASED) # ['PURCHASED', 'SHIPPED', 'NOTIFIED', 'REVIEWED']
purchase_timestamp = db.Column(db.DateTime)
shipment_timestamp = db.Column(db.DateTime)
to_notify_timestamp = db.Column(db.DateTime)
notification_timestamp = db.Column(db.DateTime)
funnel_stream_id = db.Column(db.Integer, db.ForeignKey('funnel_stream.id'))
funnel_stream = db.relationship("FunnelStream", backref=db.backref("order", uselist=False))
class Shop(db.Model, Repopulatable):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
description = db.Column(db.String)
domain = db.Column(db.String)
image_url = db.Column(db.String)
active = db.Column(db.Boolean, default=True)
automatically_approve_reviews = db.Column(db.Boolean, default=True)
access_user = db.Column(db.String)
access_token = db.Column(db.String)
products_imported = db.Column(db.Boolean, default=False)
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'),
default=current_user.id if current_user and current_user.is_authenticated() else None)
owner = db.relationship("User", backref=db.backref("shops"))
platform_id = db.Column(db.Integer, db.ForeignKey('platform.id'))
platform = db.relationship("Platform", backref=db.backref("platform"))
def __repr__(self):
return '<Shop %r>' % self.name
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(15), index=True)
surname = db.Column(db.String(40), index=True)
email = db.Column(db.String(80), index=True)
password = db.Column(db.String(100), index=True)
fcm_token = db.Column(db.String(200), index=True)
organizations = db.relationship("User_Organization_mapping",
back_populates="user")
services = db.relationship("Subscription", back_populates="user")
in_repairing = db.relationship("Service")
def __init__(self, name, surname, email, password):
self.name = name
self.surname = surname
self.email = email
self.password = password
def __repr__(self):
return 'Name: {0} \nSurname: {1} \nE-mail: {2}'.format(
self.name, self.surname, self.email)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.id)
class Studentdetail(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False,
unique=True)
name_surname = db.Column(db.String(150), nullable=False)
description = db.Column(db.String(800))
university = db.Column(db.String(120), nullable=False)
class_level = db.Column(db.Integer, nullable=False)
gpa = db.Column(db.Float, nullable=False)
active = db.Column(db.Boolean, nullable=False, default=True)
github = db.Column(db.String(180))
linkedin = db.Column(db.String(180))
img = db.Column(db.Text, nullable=True)
imgname = db.Column(db.Text, nullable=True)
mimetype = db.Column(db.Text, nullable=True)
advertisements = db.relationship('Advertisement',
secondary=advertisement_studentdetail,
lazy='subquery',
backref=db.backref('studentdetails',
lazy=True))
keywords = db.relationship('Keyword',
secondary=studentdetail_keyword,
lazy='subquery',
backref=db.backref('studentdetails', lazy=True))
def __repr__(self):
return f"Studentdetail('{self.id}', '{self.name_surname}', '{self.university}')"
class Blog(db.Model):
__tablename__ = 'blogs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(256), index=True)
body = db.Column(db.Text())
timestamp = db.Column(db.DateTime, default=datetime.utcnow(), index=True)
body_html = db.Column(db.Text())
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
looks = db.Column(db.BigInteger, default=0)
comments = db.relationship('Comment', backref='blog', lazy='dynamic')
imgs = db.relationship('BlogImgs', backref='blog', lazy='dynamic')
def __repr__(self):
return '<blog %r>' % self.title
# 博客发表
def upload_blog(self):
db.session.add(self)
db.session.commit()
# 每浏览一次，浏览量自动加一
def ping(self):
self.looks += 1
db.session.add(self)
def delete_blog_imgs(self):
for i in self.imgs:
cos_class.delete_file(i.img_url)
db.session.delete(i)
cos_class.delete_file('/users/%s/blog_img/%s/' %
(self.author.username, self.id))
#删除博客
def delete_blog(self):
for c in self.comments:
db.session.delete(c)
self.delete_blog_imgs()
db.session.delete(self)
db.session.commit()
# 将博客内容自动生成html格式
@staticmethod
def on_changed_body(target, value, oldvalue, initiator):
# 允许的标签
allowed_tags = ['a', 'abbr', 'acronym', 'b', 'blockquote', 'code',\
'em', 'i', 'li', 'ol', 'pre', 'strong', 'ul',
'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'img', 'span']
# 允许的标签属性
allowed_columns = {
'*':
['class', 'id', 'style', 'background', 'title', 'width', 'height'],
'a': ['href', 'rel'],
'img': ['src', 'alt'],
}
target.body_html = bleach.clean(value,
tags=allowed_tags,
attributes=allowed_columns,
strip=True)
class Reservation(db.Model):
id = db.Column(db.Integer, primary_key=True)
guest_id = db.Column(db.Integer, db.ForeignKey('guest.id'))
guest = db.relationship('Guest')
table_id = db.Column(db.Integer, db.ForeignKey('table.id'))
table = db.relationship('Table')
reservation_time_from = db.Column(db.String, index=True)
reservation_time_to = db.Column(db.String, index=True)
class ModuleTaskUserMap(db.Model):
__tablename__ = "module_task_user_map"
task_id = db.Column(db.Integer,
db.ForeignKey("module_task.id"),
primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), primary_key=True)
info = db.Column(db.String(1024))
user = db.relationship("User", backref="module_task_user")
module_tasks = db.relationship("ModuleTask", backref="module_task_user")
class Dog(db.Model):
__tablename__ = 'dog'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
_name = db.Column(db.String(128))
_breed = db.Column(db.String(128))
_birthday = db.Column(db.Date)
_metric = db.Column(db.String(2))
_current = db.Column(db.Float)
_goal = db.Column(db.Float)
_date = db.Column(db.Date)
_image_filename = db.Column(db.String, default=None, nullable=True)
_image_url = db.Column(db.String, default=None, nullable=True)
_thumbnail_url = db.Column(db.String, default=None, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', back_populates='dogs')
logs = db.relationship('Log', back_populates='dog')
def __init__(self,
_name,
breed,
birthday,
metric,
current,
goal,
date,
user_id,
image_filename=None,
image_url=None,
thumbnail_url=None):
self._name = _name
self._breed = breed
self._birthday = birthday
self._metric = metric
self._current = current
self._goal = goal
self._date = date
self._image_filename = image_filename
self._image_url = image_url
self._thumbnail_url = thumbnail_url
self.user_id = user_id
def to_json(self):
return {
'name': self._name,
'breed': self._breed,
'birthday': self._birthday.strftime('%m/%d/%Y'),
'current': self._current,
'goal': self._goal,
'date': self._date.strftime('%m/%d/%Y'),
'metric': self._metric,
'imageFilename': self._image_filename,
'imageUrl': self._image_url,
'thumbnailUrl': self._thumbnail_url,
'id': str(self.id)
}
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30))
last_name = db.Column(db.String(255))
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(60), nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.png')
bio = db.Column(db.TEXT, default='')
created_on = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
last_online = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
starting_cash = db.Column(db.Float, nullable=False)
cash = db.Column(db.Float, default=0.00)
portfolio_value = db.Column(db.Float, default=0.00)
portfolio_size = db.Column(db.Integer, nullable=False, default=0)
num_buys = db.Column(db.Integer, nullable=False, default=0)
num_sales = db.Column(db.Integer, nullable=False, default=0)
num_equal_sales = db.Column(db.Integer, nullable=False, default=0)
num_positive_sales = db.Column(db.Integer, nullable=False, default=0)
num_negative_sales = db.Column(db.Integer, nullable=False, default=0)
last_buy = db.Column(db.DateTime)
last_sale = db.Column(db.DateTime)
status = db.Column(db.Boolean, nullable=False, server_default='1')
access = db.Column(db.Integer, nullable=False, default=1)
roles = db.relationship('Role', secondary='user_roles')
shares = db.relationship('Share', backref='owner', lazy=True)
transactions = db.relationship('Transaction', backref='user', lazy=True)
def __repr__(self):
return f"{self.username}"
def is_admin(self):
return self.access == ACCESS['admin']
def allowed(self, access_level):
return self.access >= access_level
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)
class ReviewFeature(db.Model):
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", backref=db.backref("review_features"))
review_id = db.Column(db.Integer, db.ForeignKey('review.id'))
review = db.relationship("Review", backref=db.backref("featured"), uselist=False)
class ReviewReport(db.Model):
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", backref=db.backref("review_reports"))
review_id = db.Column(db.Integer, db.ForeignKey('review.id'))
review = db.relationship("Review", backref=db.backref("reports"))
class Answer(db.Model, Repopulatable):
id = db.Column(db.Integer, primary_key=True)
created_ts = db.Column(db.DateTime)
body = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", backref=db.backref("answers"))
question_id = db.Column(db.Integer, db.ForeignKey('question.id'))
question = db.relationship("Question", backref=db.backref("answers"))
class Hostel(db.Model):
__tablename_ = "hostel"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), unique=True)
type = db.Column(db.String(64))
rooms = db.relationship("HostelRoom", backref="hostel", lazy="dynamic")
messages = db.relationship("HostelMessage",
backref="hostel",
lazy="dynamic")
def __repr__(self):
return f"<Hostel {self.name}>"
class Campaign(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
battles = db.relationship('Battle', backref='campaign')
units = db.relationship('Unit', backref='campaign')
def __init__(self, user_id, name):
self.user_id = user_id
self.name = name
def __repr__(self):
return '<Campaign %s: %s>' % (self.id, self.name)
class Organization(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), index=True)
users = db.relationship("User_Organization_mapping",
back_populates="organization")
services = db.relationship("Service", backref='organization')
def __init__(self, name):
self.name = name
def __repr__(self):
return 'Name: {0}'.format(self.name)
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)
full_name = db.Column(db.String(64), index=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
tracks = db.relationship('Track', 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=80):
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_tracks(self):
followed = Track.query.join(
followers, (followers.c.followed_id == Track.user_id)).filter(
followers.c.follower_id == self.id)
own = Track.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Track.timestamp.desc)
def __repr__(self):
return '<User {}>'.format(self.username)
class HostelRoomUserMap(db.Model):
__tablename__ = "hostel_room_user_map"
hostel_room_id = db.Column(db.Integer,
db.ForeignKey("hostel_room.id"),
primary_key=True)
academic_year = db.Column(db.Integer, primary_key=True)
semester = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User", backref="hostel_room_user")
hostel_room = db.relationship(
"HostelRoom",
backref=db.backref(
"hostel_room_user",
cascade="save-update, merge, delete, delete-orphan"))
class Question(db.Model, Repopulatable, RenderableObject):
id = db.Column(db.Integer, primary_key=True)
created_ts = db.Column(db.DateTime)
body = db.Column(db.String)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", backref=db.backref("questions"))
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
product = db.relationship("Product", backref=db.backref("questions"))
click_count = db.Column(db.Integer, default=0)
is_public = db.Column(db.Boolean, default=False)
class Log(db.Model):
__tablename__ = 'log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
_date = db.Column(db.Date)
_weight = db.Column(db.Float, default=None, nullable=True)
_total_duration = db.Column(db.Integer, default=None)
_total_calories = db.Column(db.Integer, default=None)
_daily_calories = db.Column(db.Float, default=None)
_image_filename = db.Column(db.String, default=None, nullable=True)
_image_url = db.Column(db.String, default=None, nullable=True)
_thumbnail_url = db.Column(db.String, default=None, nullable=True)
food_logs = db.relationship('FoodLog', back_populates='log')
exercise_logs = db.relationship('ExerciseLog', back_populates='log')
dog_id = db.Column(db.Integer, db.ForeignKey('dog.id'))
dog = db.relationship('Dog', back_populates='logs')
def __init__(self,
date,
dog_id,
weight=None,
daily_calories=None,
total_calories=None,
total_duration=None,
image_filename=None,
image_url=None,
thumbnail_url=None):
self._date = date
self.dog_id = dog_id
self._weight = weight
self._daily_calories = daily_calories
self._total_calories = total_calories
self._total_duration = total_duration
self._image_filename = image_filename
self._image_url = image_url
self._thumbnail_url = thumbnail_url
def to_json(self):
return {
'id': str(self.id),
'date': self._date.strftime('%m/%d/%Y'),
'weight': self._weight,
'dailyCalories': self._daily_calories,
'totalCalories': self._total_calories,
'totalDuration': self._total_duration,
'imageFilename': self._image_filename,
'imageUrl': self._image_url,
'thumbnailUrl': self._thumbnail_url
}
class User(db.Model):
__tablename__ = 'user'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(40), nullable=False)
Lastname = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(40), nullable=False)
phone = db.Column(db.String(15), unique=True, nullable=False)
details = db.relationship('Details', backref='user', uselist=False)
password = db.relationship('Credential', backref='user', uselist=False)
roll = db.Column(db.String(4), nullable=False)
def __init__(self, firstname, lastname, email, phone, address, dob,
password, roll):
self.email = email
self.roll = roll
self.firstname = firstname
self.Lastname = lastname
self.phone = phone
self.details = Details(user_id=self.id, address=address, dob=dob)
self.password = Credential(user_id=self.id, password=password)
def serialize(self):
# print(self.details[0].serialize())
data = {
'id': self.id,
'firstname': self.firstname,
'lastname': self.Lastname,
'phone': self.phone,
'address': self.details.address,
'roll': self.roll,
'dob': datetime.strftime(self.details.dob, '%Y-%B-%d'),
'email': self.email
}
return data
def dbserialize(self):
data = {
'id': self.id,
'firstname': self.firstname,
'lastname': self.Lastname,
'email': self.email,
'phone': self.phone,
'address': self.details.address,
'dob': datetime.strftime(self.details.dob, '%Y-%m-%d'),
'password': self.password.cpassword,
'roll': self.roll
}
return data
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
celery_uuid = db.Column(db.String)
eta = db.Column(db.DateTime)
status = db.Column(db.String)
method = db.Column(db.String)
kwargs = db.Column(db.String)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'))
order = db.relationship("Order", backref=db.backref("tasks"))
funnel_stream_id = db.Column(db.Integer, db.ForeignKey('funnel_stream.id'))
funnel_stream = db.relationship("FunnelStream", backref=db.backref("tasks"))
class Task(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
time_added = db.Column(db.DateTime,
nullable=False,
default=datetime.now(tz))
time_updated = db.Column(db.DateTime,
default=datetime.now(tz),
onupdate=datetime.now(tz))
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(250), nullable=False)
deadline = db.Column(db.DateTime, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
subject_id = db.Column(db.Integer,
db.ForeignKey('subject.id'),
nullable=False)
comment = db.relationship('Comment',
backref='task',
lazy=True,
foreign_keys="Comment.task_id")
def __repr__(self):
return f"Task('{self.name}', '{self.description}', '{self.deadline}')"
class Album(db.Model):
id = db.Column(db.Integer, primary_key=True)
sku = db.Column(db.String(255), nullable=False)
artist_id = db.Column(db.Integer, db.ForeignKey(
"artist.id"), nullable=False)
title = db.Column(db.String(1024), nullable=False)
year = db.Column(db.Integer, nullable=False)
format = db.Column(db.String(255), nullable=False)
price = db.Column(db.Float(), nullable=False)
tracks = db.relationship('Track', backref='Album', lazy=True)
@property
def album_art(self):
id_album = list(str(self.id))
id_album.reverse()
filepath = '/'.join(id_album)
albumart = os.path.join(app.static_folder, 'albumart')
filename = os.path.join(albumart, filepath, f'{self.id}.jpg')
if os.path.exists(filename) and (os.path.getsize(filename) > 0):
return f"/static/albumart/{filepath}/{self.id}.jpg"
else:
return "/static/img/no-albumart.svg"
def __repr__(self):
return f"Album('{self.name}')"
class Artist(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
albums = db.relationship('Album', backref='artist', lazy=True)
def __repr__(self):
return f"Artist('{self.name}')"
class Account(db.Model):
__tablename__ = "wx_account"
__table_args__ = {
"useexisting": True,
'mysql_charset': 'utf8mb4'
}
id = db.Column(db.Integer, primary_key=True)
account_name = db.Column(db.String(50)) # 公众号名称
account_id = db.Column(db.String(30), unique=True) # 公众号唯一id
account_biz = db.Column(db.String(20), unique=True) # 公众号__biz
account_id_unique = db.Column(db.String(30), unique=True) # 公众号唯一id
account_logo = db.Column(db.String(300), unique=True) # 公众号头像
account_desc = db.Column(db.String(300)) # 公众号描述
account_url = db.Column(db.String(500), unique=True) # 公众号解析链接
created = db.Column(db.String(20), default=str(int(time.time()))) # 公众号添加时间
status = db.Column(db.Integer, default=0) # 状态0-未运行，1-等待中，2-运行中，3-已暂停
offset = db.Column(db.Integer, default=0) # 公众号偏移量
counts = db.Column(db.Integer, default=0) # 公众号获取的文章数量
end = db.Column(db.Boolean, default=False) # 公众号爬取是否完毕
fail = db.Column(db.Boolean, default=False) # 公众号有效性
update = db.Column(db.String(20), default="1356969600") # 公众号更新时间
articles = db.relationship("Article", backref="wx_account")
def __repr__(self):
return "<Account: %s %s %s %s>" % (self.account_name, self.account_id, self.offset, self.end)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
cat_name = db.Column(db.String(), unique=True, nullable=False)
dish = db.relationship('Dish', backref='category', lazy=True)
def __repr__(self):
return f"Categeory: '{self.cat_name}'"
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}')"
