class Role(ModelMixin, RoleMixin, db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
parents = db.relationship('Role',
secondary=roles_parents,
primaryjoin=(id == roles_parents.c.role_id),
secondaryjoin=(id == roles_parents.c.parent_id),
backref=db.backref('children', lazy='dynamic'))
users = db.relationship('User',
secondary=users_roles,
backref=db.backref('roles', lazy='dynamic'))
def __init__(self, name):
RoleMixin.__init__(self)
self.name = name
def add_parent(self, parent):
# You don't need to add this role to parent's children set,
# relationship between roles would do this work automatically
self.parents.append(parent)
def add_parents(self, *parents):
for parent in parents:
self.add_parent(parent)
@staticmethod
def get_by_name(name):
return Role.query.filter_by(name=name).first()
class Menu(db.Model):
__tablename__ = 'menu'
CATEGORY_STATE_VALUES = ['normal', 'deleted']
mid = db.Column(db.Integer, primary_key=True)
mname = db.Column(db.String(16))
type = db.Column(db.Integer, default=1) #默认为1，1为一级目录，2为二级目录，不支持更高级目录
query_id = db.Column(db.Integer, default=0)
father_mid = db.Column(db.Integer, default=0) #区分二级目录归在哪个一级目录下
url = db.Column(db.String(50))
create_date = db.Column(db.DateTime, default=datetime.utcnow)
state = db.Column(db.Enum(*CATEGORY_STATE_VALUES), default='normal')
def __str__(self):
return "%s" % self.mname
def __repr__(self):
return "<Category %s>" % self.mname
def delete(self, commit=True):
db.session.delete(self)
if commit:
db.session.commit()
def jsonify(self):
return {
'mid': self.mid,
'mname': self.mname,
'type': self.type,
'query_id': self.query_id,
'father_mid': self.father_mid,
'url': self.url
}
class Category(ModelMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32))
urlstr = db.Column(db.String(16))
articles = db.relationship('Article', backref='category')
def __str__(self):
return "%s" % self.name
def __repr__(self):
return "<Category %s>" % self.name
def delete(self, commit=True):
for article in self.articles:
article.delete(False)
db.session.add(self)
if commit:
db.session.commit()
class Article(ModelMixin, db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
description = db.Column(db.Text)
create_date = db.Column(db.DateTime, default=datetime.utcnow)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
deleted = db.Column(db.BOOLEAN, default=False)
def delete(self, commit=True):
self.deleted = True
db.session.add(self)
if commit:
db.session.commit()
def __str__(self):
return ("%s" % self.name)
def __repr__(self):
return "<Article %s>" % self.name
class Log(ModelMixin, db.Model):
TYPE_TEXT = ('login', 'operation')
LEVEL = ('danger', 'warn', 'normal')
type = db.Column(db.Enum(*TYPE_TEXT))
level = db.Column(db.Enum(*LEVEL))
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
time = db.Column(db.DATETIME, default=datetime.now())
file = db.Column(db.String(250), default='none')
module = db.Column(db.String(50))
view_func = db.Column(db.String(50))
method = db.Column(db.String(6))
args = db.Column(db.String(250))
ip = db.Column(db.String(30))
user = db.relationship('User',
backref=db.backref('logs', lazy='dynamic'),
uselist=False)
class User(ModelMixin, UserMixin, db.Model):
"""Model of user."""
__tablename__ = 'user'
query_class = UserQuery
USER_STATE_VALUES = ('normal', 'frozen', 'deleted', 'unactivated')
USER_STATE_TEXTS = ('Normal', 'Frozen', 'Deleted', 'Unactivated')
id = db.Column(db.Integer, primary_key=True)
loginname = db.Column(db.String(30), nullable=False)
hashed_password = db.Column(db.String(64))
nickname = db.Column(db.String(16), unique=True)
email = db.Column(db.String(50), nullable=True)
phone = db.Column(db.String(11), nullable=True)
qq = db.Column(db.String(15), nullable=True)
avatar = db.Column(db.String(250))
create_date = db.Column(db.DateTime, default=datetime.now())
salt = db.Column(db.String(32), nullable=False)
state = db.Column(db.Enum(*USER_STATE_VALUES), default='normal')
def __init__(self, **kwargs):
self.salt = uuid4().hex
if 'loginname' in kwargs:
loginname = kwargs.pop('loginname')
self.loginname = loginname.lower()
if 'passwd' in kwargs:
raw_passwd = kwargs.pop('passwd')
self.change_password(raw_passwd)
if 'nickname' in kwargs:
nickname = kwargs.pop('nickname')
self.nickname = nickname.lower()
db.Model.__init__(self, **kwargs)
def __unicode__(self):
return self.loginname
def __repr__(self):
return "<User: %s>" % self.loginname
def change_password(self, raw_passwd):
self.salt = uuid4().hex
self.hashed_password = self._hash_password(self.salt, raw_passwd)
def check_password(self, raw_passwd):
_hashed_password = self._hash_password(self.salt, raw_passwd)
return self.hashed_password == _hashed_password
def has_email(self):
return not self.email is None
def check_email(self, email):
return self.email == email
def is_active(self):
return self.state == 'normal'
def is_anonymous(self):
return self.nickname is None
def get_id(self):
return self.id
def get_role(self):
if self.roles[0].name == u"superuser":
return u"超级管理员"
elif self.roles[0].name == u"manager":
return u"管理员"
def jsonify(self):
return {
'id': self.id,
'loginname': self.loginname,
'nickname': self.nickname,
'email': self.email,
'qq': self.qq,
'phone': self.phone,
'create_date': self.create_date,
'state': self.state
}
def is_authenticated(self):
return self.state in ('normal', 'unactivated')
def active(self):
self.state = 'normal'
def get_avatar(self, size=70):
if self.avatar:
return self.avatar
if not self.email:
self.email = 'None'
URL_PATTERN = "http://www.gravatar.com/avatar/%s?%s"
gravatar_url = URL_PATTERN % (md5(self.email.lower()).hexdigest(),
urllib.urlencode({'s': str(size)}))
return gravatar_url
def set_avatar(self, avatar_url):
self.avatar = avatar_url
@staticmethod
def _hash_password(salt, password):
hashed = sha256()
hashed.update("<%s|%s>" % (salt, password))
return hashed.hexdigest()
from flask_rbac import RoleMixin, UserMixin
from flask.ext.sqlalchemy import BaseQuery
from cms.models import db, ModelMixin
class UserQuery(BaseQuery):
def authenticate(self, loginname, raw_passwd):
user = self.filter(User.loginname == loginname).first()
if user and user.check_password(raw_passwd):
return user
return None
roles_parents = db.Table(
'roles_parents', db.Column('role_id', db.Integer,
db.ForeignKey('role.id')),
db.Column('parent_id', db.Integer, db.ForeignKey('role.id')))
users_roles = db.Table(
'users_roles', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('role_id', db.Integer, db.ForeignKey('role.id')))
class Role(ModelMixin, RoleMixin, db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
parents = db.relationship('Role',
secondary=roles_parents,
primaryjoin=(id == roles_parents.c.role_id),