class Feed(db.Model):
__tablename__ = "feeds"
id = db.Column(db.Integer(), primary_key=1)
url = db.Column(db.String(255), unique=1)
account_id = db.Column(db.Integer(), db.ForeignKey("accounts.id"))
def __init__(self, url="", account=None):
self.url = url
self.account = account
def __repr__(self):
return self.account.text + u"的订阅地址"
def to_json(self):
feed = dict()
feed["id"] = self.id
feed["url"] = self.url
feed["account"] = self.account
return feed
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user_model.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
def __repr__(self):
return '<UserRoles %r>' % self.name
class Role(db.Model, RoleMixin):
__tablename__ = "role"
id = db.Column(db.Integer(), primary_key=1, autoincrement=1)
name = db.Column(db.String(255), unique=1)
description = db.Column(db.String(255))
def __init__(self, name="", description=""):
self.name = name
self.description = description
def __repr__(self):
return self.name
def to_json(self):
role = dict()
role["id"] = self.id
role["name"] = self.name
role["description"] = self.description
return role
class Board(db.Model, TimestampMixin):
id = db.Column(db.Integer, primary_key=True, nullable=False)
title = db.Column(db.String(200), nullable=False)
description = db.Column(db.String(200), nullable=True)
status = db.Column(ChoiceType(BoardStatus, impl=db.Integer()), default=BoardStatus.NORMAL)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship("User")
posts = db.relationship("Post", backref="board", lazy='dynamic')
@hybrid_property
def is_deleted(self):
return self.status == BoardStatus.DELETED
def delete(self):
self.status = BoardStatus.DELETED
def is_owner(self, user: User):
return self.user_id == user.id
def __repr__(self):
return "<Board title: %s, description: %s, status: %s," \
" created_at: %s, updated_at: %s>"\
% (self.title, self.description, self.status,
self.created_at, self.updated_at)
class ProxyIP(db.Model):
__tablename__ = "proxy_ip"
id = db.Column(db.Integer(), primary_key=1)
ip_port = db.Column(db.String(20), unique=1, nullable=0)
quality = db.Column(db.String(20))
def __init__(self, ip_port="", quality=""):
self.ip_port = ip_port
self.quality = quality
def __repr__(self):
return self.ip_port
def to_json(self):
proxy_ip = dict()
proxy_ip["ip_port"] = self.ip_port
proxy_ip["quality"] = self.quality
return proxy_ip
class ProxySite(db.Model):
__tablename__ = "proxy_site"
id = db.Column(db.Integer(), primary_key=1)
url = db.Column(db.String(255))
regex = db.Column(db.String(255))
def __init__(self, url="", regex=""):
self.url = url
self.regex = regex
def __repr__(self):
return self.url
def to_json(self):
proxy_site = dict()
proxy_site["url"] = self.url
proxy_site["regex"] = self.regex
return proxy_site
class OauthModel(db.Model):
id = db.Column(db.Integer(), primary_key=True)
client_id = db.Column(db.String(255), unique=True)
client_secret = db.Column(db.String(255))
redirect_uri = db.Column(db.String(255))
def __init__(self, client_id, client_secret, redirect_uri):
self.client_id = client_id
self.client_secret = client_secret
self.redirect_uri = redirect_uri
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return '<Role %r>' % self.name
class Account(db.Model):
__tablename__ = "accounts"
id = db.Column(db.Integer(), primary_key=1)
name = db.Column(db.String(255), unique=1, nullable=0)
text = db.Column(db.String(255), unique=1, nullable=0)
info = db.Column(db.String(255), unique=0, nullable=1)
auth = db.Column(db.String(255), unique=0, nullable=1)
feed = db.relationship("Feed",
cascade="all,delete",
backref="account",
uselist=0)
articles = db.relationship("Article",
cascade="all,delete",
backref="account",
lazy="dynamic")
def __init__(self, name="", text="", info="", auth=""):
self.name = name
self.text = text
self.info = info
self.auth = auth
def __repr__(self):
return self.text
def to_json(self):
account = dict()
account["id"] = self.id
account["name"] = self.name
account["text"] = self.text
account["info"] = self.info
account["auth"] = self.auth
return account
class Location(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80))
lat = db.Column(db.Float())
lng = db.Column(db.Float())
# for faster calculation of Distance Difference
Index('dist', func.ll_to_earth(lat, lng), postgresql_using='gist')
def __init__(self, name, lat, lng):
self.name = name
self.lat = lat
self.lng = lng
class Comment(db.Model, TimestampMixin):
id = db.Column(db.Integer, primary_key=True, nullable=False)
content = db.Column(db.Text, nullable=False)
status = db.Column(ChoiceType(CommentStatus, impl=db.Integer()),
default=CommentStatus.NORMAL)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship("User")
comment_group_id = db.Column(db.Integer,
db.ForeignKey('comment_group.id'),
nullable=False)
parent_id = db.Column(db.Integer,
db.ForeignKey('comment.id'),
nullable=True)
depth = db.Column(db.Integer, nullable=False, default=0)
step = db.Column(db.Integer, nullable=False, default=0)
edited_count = db.Column(db.Integer, default=0)
def delete(self):
self.comment_group.post.decrease_comment_count()
self.status = CommentStatus.DELETED
db.session.commit()
@hybrid_property
def is_deleted(self):
return self.status == CommentStatus.DELETED
def is_owner(self, user: User):
return self.user_id == user.id
def update(self, data):
self.content = data
self.edited_count = Comment.edited_count + 1
db.session.commit()
def __repr__(self):
return "<Comment content: %s, status: %s" \
" created_at: %s, updated_at: %s>"\
% (self.content, self.status,
self.created_at, self.updated_at)
class User(db.Model, UserMixin):
__tablename__ = "user"
id = db.Column(db.Integer(), primary_key=1)
email = db.Column(db.String(255), unique=1)
active = db.Column(db.Boolean())
password = db.Column(db.String(255))
# confirmed_at = db.Column(db.DateTime())
roles = db.relationship("Role", secondary=roles_users, backref=db.backref("users", lazy="dynamic"))
def __init__(self, email="", active=1, password="", roles=None):
self.roles = roles
self.email = email
self.active = active
self.password = password
def __repr__(self):
return self.email
def to_json(self):
user = dict()
user["id"] = self.id
user["roles"] = self.roles
user["email"] = self.email
user["active"] = self.active
return user
class User(UserMixin, db.Model, TimestampMixin):
id = db.Column(db.Integer, primary_key=True, nullable=False)
email = db.Column(db.String(200), unique=True, nullable=False, index=True)
password = db.Column(db.String(200), nullable=False)
status = db.Column(ChoiceType(UserStatus, impl=db.Integer()),
default=UserStatus.ACTIVE)
def encode_password(self):
self.password = generate_password_hash(self.password)
def check_password(self, password):
return check_password_hash(self.password, password)
def is_active(self):
return self.status == UserStatus.ACTIVE
def leave(self):
self.status = UserStatus.INACTIVE
def is_exists(self):
temp = User.query.filter(User.email == self.email).one_or_none()
if temp:
return True
else:
return False
def is_liked(self, post_id):
if Likes.query.filter(Likes.post_id == post_id,
Likes.user_id == self.id).one_or_none():
return True
return False
def __repr__(self):
return "<User email: %s, password: %s, created_at: %s, updated_at: %s>" \
% (self.email, self.password, self.created_at, self.updated_at)
class Article(db.Model):
__tablename__ = "articles"
id = db.Column(db.Integer(), primary_key=1)
title = db.Column(db.String(255), unique=1)
cover = db.Column(db.String(255))
digest = db.Column(db.String(255))
content = db.Column(db.Text())
read_num = db.Column(db.Integer())
post_date = db.Column(db.Date())
account_id = db.Column(db.Integer(), db.ForeignKey("accounts.id"))
def __init__(self,
title="",
cover="",
digest="",
content="",
read_num=0,
post_date="",
account=None):
self.title = title
self.cover = cover
self.digest = digest
self.content = content
self.account = account
self.read_num = read_num
self.post_date = post_date
def __repr__(self):
return self.title
def to_json(self):
article = dict()
article["id"] = self.id
article["title"] = self.title
article["cover"] = self.cover
article["digest"] = self.digest
article["content"] = self.content
article["account"] = self.account
article["read_num"] = self.read_num
article["post_date"] = self.post_date
return article
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
# -*- coding: utf-8 -*-
from datetime import datetime
from flask.ext.security import SQLAlchemyUserDatastore, UserMixin, RoleMixin
from app.model import db
# Define models required for Flask-Security
roles_users = db.Table('roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(),
db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key = True)
email = db.Column(db.String(64), unique = True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def is_authenticated(self):
return True
def is_active(self):
return True
