class Action(BaseModel, db.Model):
"""权限表"""
__tablename__ = 'actions'
id = db.Column(db.String(45), primary_key=True)
#source_id = db.Column(db.String(45), db.ForeignKey('sources.id'))
name = db.Column(db.String(128))
type = db.Column(db.String(32))
code = db.Column(db.String(45), unique=True)
comments = db.Column(db.String(255))
def __init__(self, action_name):
self.id = str(uuid4())
self.name = action_name
def to_json(self):
json_post = {
'id': self.id,
'name': self.name,
'type': self.type,
'code': self.code,
'comments': self.comments,
'status': self.status,
'create_time': self.created_time
}
return json_post
def __repr__(self):
return '<Model Action `{}`>'.format(self.name)
class Dictionary(BaseModel, db.Model):
"""dictionary detail"""
__tablename__ = 'dictionary'
id = db.Column(db.String(45), primary_key=True)
name = db.Column(db.String(100))
code = db.Column(db.String(45), unique=True)
order = db.Column(db.Integer)
catalog_id = db.Column(db.Integer, db.ForeignKey('catalog.id'))
def __init__(self, name):
self.name = name
def __repr__(self):
return 'dict'
def to_json(self):
json_post = {
'id': self.id,
'name': self.name,
'order': self.order,
'code': self.code,
'status': self.status,
'create_time': self.created_time,
'update_time': self.modified_time
}
return json_post
class Comment(BaseModel, db.Model):
"""Represents Proected comments."""
__tablename__ = 'comments'
id = db.Column(db.String(45), primary_key=True)
name = db.Column(db.String(255))
text = db.Column(db.Text())
date = db.Column(db.DateTime())
post_id = db.Column(db.String(45), db.ForeignKey('posts.id'))
def __init__(self, name):
self.name = name
self.id = str(uuid4())
def to_json(self):
json_comment = {
'id': self.id,
'name': self.name,
'content': self.text,
'reviewers': self.creater,
'status': self.status,
'post_title': self.posts.title,
'date': self.date,
'create_time': self.created_time
}
return json_comment
def __repr__(self):
return '<Model Comment `{}`>'.format(self.name)
class Catalog(BaseModel, db.Model):
"""dictionary catalog"""
__tablename__ = 'catalog'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(40), nullable=False, unique=True)
code = db.Column(db.String(45), unique=True)
is_show = db.Column(db.String(32))
comments = db.Column(db.String(255))
dictionaries = db.relationship('Dictionary', backref='catalog')
def __init__(self, name):
self.name = name
def __repr__(self):
return 'Catalog'
def to_json(self):
json_post = {
'id': self.id,
'name': self.name,
'code': self.code,
'is_show': self.is_show,
'comments': self.comments,
'status': self.status,
'create_time': self.created_time,
'update_time': self.modified_time
}
return json_post
class Role(BaseModel, db.Model):
"""Represents Proected roles."""
__tablename__ = 'roles'
id = db.Column(db.String(45), primary_key=True)
name = db.Column(db.String(255), unique=True)
description = db.Column(db.String(255))
actions = db.relationship('Action',
secondary=roles_actions,
backref=db.backref('roles', lazy='dynamic'))
def __init__(self, name):
self.id = str(uuid4())
self.name = name
def has_permission(self, perm):
# return self.permissions & perm == perm
pass
def to_json(self):
json_post = {
'id': self.id,
'name': self.name,
'description': self.description,
'status': self.status,
'create_time': self.created_time,
'update_time': self.modified_time
}
return json_post
def __repr__(self):
return "<Model Role `{}`>".format(self.name)
class BaseModel(object):
"""Base class"""
# 1:enabled 0:disabled
status_ = db.Column(db.Integer, default=1, comment='状态，1->启用，0->禁用')
created_time = db.Column(db.DATETIME,
default=datetime.datetime.now(),
comment='创建时间')
creater = db.Column(db.String(45), default='null')
modified_time = db.Column(db.DATETIME,
default=datetime.datetime.now(),
onupdate=datetime.datetime.now(),
comment='修改时间')
modifier = db.Column(db.String(45), default='null')
def add_or_update(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@property
def status(self):
return self.status_
@status.setter
def status(self, s):
if s == 'on':
self.status_ = 1
else:
self.status_ = 0
class Attachment(db.Model):
"""附件资源表"""
__tablename__ = 'attachments'
id = db.Column(db.String(45), primary_key=True)
attach_name = db.Column(db.String(255))
path = db.Column(db.Text())
belong_type = db.Column(db.String(45))
belong_id = db.Column(db.String(45))
def __init__(self):
self.id = str(uuid4())
class GDConfig(db.Model):
__tablename__ = 'gd_config_t'
device_uuid = db.Column(db.String(64), primary_key=True)
ppp_id = db.Column(db.Integer, primary_key=True)
ppp_addr = db.Column(db.String(64))
ppp_user = db.Column(db.String(128))
ppp_passwd = db.Column(db.String(128))
ppp_vlan_id = db.Column(db.Integer)
ppp_vlan_addr = db.Column(db.String(64))
ppp_vlan_parent = db.Column(db.String(24))
def __init__(self, data):
self.device_uuid = data.get("device_uuid")
self.ppp_addr = data.get("ppp_id")
self.ppp_addr = data.get("ppp_addr")
self.ppp_user = data.get("ppp_user")
self.ppp_passwd = data.get("ppp_passwd")
self.ppp_vlan_id = data.get("ppp_vlan_id")
self.ppp_vlan_addr = data.get("ppp_vlan_addr")
self.ppp_vlan_parent = data.get("ppp_vlan_parent")
def to_json(self):
return {
"ppp_id": self.ppp_id,
"ppp_addr": self.ppp_addr,
"ppp_user": self.ppp_user,
"ppp_passwd": self.ppp_passwd,
"ppp_vlan_id": self.ppp_vlan_id,
"ppp_vlan_addr": self.ppp_vlan_addr,
"ppp_vlan_parent": self.ppp_vlan_parent,
}
class Mail(BaseModel, db.Model):
"""Represents Proected reminders."""
__tablename__ = 'mails'
id = db.Column(db.String(45), primary_key=True)
user_id = db.Column(db.String(45), db.ForeignKey('users.id'))
#date = db.Column(db.DateTime())
email = db.Column(db.String(255))
text = db.Column(db.Text())
def __init__(self, text):
self.id = str(uuid4())
self.email = text
def __repr__(self):
return '<Model Mail `{}`>'.format(self.text[:20])
class GDIsp(db.Model):
__tablename__ = 'gd_isp_t'
isp_id = db.Column(db.Integer,
unique=True,
nullable=False,
primary_key=True)
isp_name = db.Column(db.String(128))
def __init__(self, id_, name_):
self.isp_id = id_
self.isp_name = name_
def to_json(self):
return {"isp_id": self.isp_id, "isp_name": self.isp_name}
def to_list(self):
return [self.isp_id, self.isp_name]
class GDProvince(db.Model):
__tablename__ = 'gd_province_t'
province_id = db.Column(db.Integer, primary_key=True)
province_name = db.Column(db.String(40))
def __init__(self, id_, name_):
self.province_id = id_
self.province_name = name_
def to_json(self):
return {
'province_id': self.province_id,
'province_name': self.province_name
}
def to_list(self):
return [self.province_id, self.province_name]
class GDUser(db.Model, flask_login.UserMixin):
__tablename__ = 'gd_user_t'
id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True)
user_name = db.Column(db.String(64), unique=True, nullable=False)
password = db.Column(db.String(64))
email = db.Column(db.String(64))
status = db.Column(db.SmallInteger,
nullable=False,
default=1,
doc="用户状态，0-禁用，1-启动")
create_datetime = db.Column(db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
doc="创建时间")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
doc="更新时间")
def is_active(self):
if self.status:
return True
return False
#
# create token with user id
#
def get_id(self):
key = current_app.secret_key
s = URLSafeSerializer(key)
data = {'id': self.id, 'time': time.time()}
token = s.dumps(data)
return token
class Post(BaseModel, db.Model):
"""Represents Proected posts."""
__tablename__ = 'posts'
id = db.Column(db.String(45), primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text())
publish_date = db.Column(db.DateTime)
# Set the foreign key for Post
user_id = db.Column(db.String(45), db.ForeignKey('users.id'))
# Establish contact with Comment's ForeignKey: post_id
comments = db.relationship('Comment', backref='posts', lazy='dynamic')
# many to many: posts <==> tags
tags = db.relationship('Tag',
secondary=posts_tags,
backref=db.backref('posts', lazy='dynamic'))
def __init__(self, title):
self.id = str(uuid4())
self.title = title
def get_tag(self):
tags = Tag.query.join(posts_tags).join(Post).filter(Post.id == self.id)
str = []
for t in tags:
str.append(t.name)
return ','.join(str)
def __repr__(self):
return "<Model Post `{}`>".format(self.title)
def to_json(self):
json_post = {
'id': self.id,
'title': self.title,
'text': self.text,
'publish_date': self.publish_date,
'author': self.users.username,
'tag': self.get_tag(),
'status': self.status,
'created_time': self.created_time
}
return json_post
class Group(BaseModel, db.Model):
"""用户组"""
__tablename__ = 'group'
id = db.Column(db.String(45), primary_key=True)
group_name = db.Column(db.String(64))
parent_id = db.Column(db.String(45))
level_no = db.Column(db.Integer) #最大支持3级
comments = db.Column(db.String(255))
users = db.relationship('User',
secondary=user_group,
backref=db.backref('group', lazy='dynamic'))
def __init__(self, group_name):
self.id = str(uuid4())
self.group_name = group_name
@property
def level(self):
return self.level_no
@level.setter
def level(self, num):
if num.isdigit() and num > 0 and num <= 3:
self.level_no = num
else:
raise AttributeError('level错误，level范围为1-3')
def to_json(self):
json_post = {
'id': self.id,
'group_name': self.group_name,
'parent_id': self.parent_id,
'level': self.level,
'comments': self.comments,
'status': self.status,
'create_time': self.created_time
}
return json_post
def __repr__(self):
return '<Model Group `{}`>'.format(self.group_name)
class GDNetflow(db.Model):
__tablename__ = 'gd_netflow_t'
date_time = db.Column(db.DateTime, primary_key=True)
device_uuid = db.Column(db.String(64), primary_key=True)
interface_name = db.Column(db.String(64), primary_key=True)
netflow_up = db.Column(db.Integer)
netflow_down = db.Column(db.Integer)
def __init__(self, data):
self.date_time = data.get("date_time")
self.device_uuid = data.get("device_uuid")
self.interface_name = data.get("interface_name")
self.netflow_up = data.get("netflow_up")
self.netflow_down = data.get("netflow_down")
def to_json(self):
return {
"date_time": self.date_time,
"device_uuid": self.device_uuid,
"interface_name": self.interface_name,
"netflow_up": self.netflow_up,
"netflow_down": self.netflow_down
}
class Tag(BaseModel, db.Model):
"""Represents Proected tags."""
__tablename__ = 'tags'
id = db.Column(db.String(45), primary_key=True)
name = db.Column(db.String(255))
def __init__(self, name):
self.id = str(uuid4())
self.name = name
def to_json(self):
json_tag = {
'id': self.id,
'name': self.name,
'status': self.status,
'update_time': self.modified_time,
'create_time': self.created_time
}
return json_tag
def __repr__(self):
return "<Model Tag `{}`>".format(self.name)
class ActionLog(db.Model):
"""操作日志"""
__tablename__ = 'action_log'
id = db.Column(db.String(45), primary_key=True)
action_name = db.Column(db.String(128))
client_ip = db.Column(db.String(128))
action_time = db.Column(db.DateTime())
def __init__(self, action_name):
self.id = str(uuid4())
self.action_name = action_name
def to_json(self):
json_post = {
'id': self.id,
'action_name': self.action_name,
'client_ip': self.client_ip,
'action_time': self.action_time
}
return json_post
def __repr__(self):
return '<Model ActionLog `{}`>'.format(self.action_name)
class Resource(BaseModel, db.Model):
"""菜单资源表"""
__tablename__ = 'resources'
id = db.Column(db.String(45), primary_key=True)
name = db.Column(db.String(128))
pid = db.Column(db.String(45))
icon = db.Column(db.String(50))
url = db.Column(db.String(250))
order = db.Column(db.SmallInteger, default=0)
bg_color = db.Column(db.String(50))
comments = db.Column(db.String(255))
roles = db.relationship('Role',
secondary=roles_resources,
backref=db.backref('resources', lazy='dynamic'))
def __init__(self, source_name):
self.id = str(uuid4())
self.source_name = source_name
def to_json(self):
json_post = {
'id': self.id,
'name': self.name,
'pid': self.pid,
'icon': self.icon,
'url': self.url,
'order': self.order,
'bg_color': self.bg_color,
'comments': self.comments,
'status': self.status,
'create_time': self.created_time
}
return json_post
def __repr__(self):
return '<Model Resoure `{}`>'.format(self.name)
class GDDevice(db.Model):
__tablename__ = 'gd_device_t'
dev_uuid = db.Column(db.String(64), unique=True, primary_key=True)
mac_addr = db.Column(db.String(64),
unique=True,
nullable=False,
primary_key=True)
provider = db.Column(db.Integer)
cpu_model = db.Column(db.String(64))
cpu_cores = db.Column(db.Integer)
total_mem = db.Column(db.Integer)
nic_type = db.Column(db.String(64))
nic_count = db.Column(db.Integer)
total_storage = db.Column(db.Integer)
disk_details = db.Column(db.String(64))
system_version = db.Column(db.String(64))
kernel_version = db.Column(db.String(64))
isp = db.Column(db.Integer)
province = db.Column(db.Integer)
city = db.Column(db.String(32))
up_bandwidth = db.Column(db.Integer)
ip = db.Column(db.String(64))
web_port = db.Column(db.Integer)
online_time = db.Column(db.Integer)
upstream_traffic = db.Column(db.Integer)
downstream_traffic = db.Column(db.Integer)
pass_time = db.Column(db.DateTime)
link_upload_speed = db.Column(db.Integer)
zone = db.Column(db.String(64))
customer = db.Column(db.String(64))
def __init__(self, data):
self.mac_addr = data.get("mac_addr")
self.provider = data.get("provider")
self.cpu_model = data.get("cpu_model")
self.cpu_cores = data.get("cpu_cores")
self.total_mem = data.get("total_mem")
self.nic_type = data.get("nic_type")
self.nic_count = data.get("nic_count")
self.total_storage = data.get("total_storage")
self.disk_details = data.get("disk_details")
self.system_version = data.get("system_version")
self.kernel_version = data.get("kernel_version")
self.isp = data.get("isp")
self.province = data.get("province")
self.city = data.get("city")
self.up_bandwidth = data.get("up_bandwidth")
self.ip = data.get("ip")
self.web_port = data.get("web_port")
self.online_time = data.get("online_time")
self.upstream_traffic = data.get("upstream_traffic")
self.downstream_traffic = data.get("downstream_traffic")
self.pass_time = data.get("pass_time")
self.dev_uuid = data.get("dev_uuid")
self.link_upload_speed = data.get("link_upload_speed")
self.zone = data.get("zone")
self.customer = data.get("customer")
def to_json(self):
return {
"mac_addr": self.mac_addr,
"provider": self.provider,
"cpu_model": self.cpu_model,
"cpu_cores": self.cpu_cores,
"total_mem": self.total_mem,
"nic_type": self.nic_type,
"nic_count": self.nic_count,
"total_storage": self.total_storage,
"disk_details": self.disk_details,
"system_version": self.system_version,
"kernel_version": self.kernel_version,
"isp": self.isp,
"province": self.province,
"city": self.city,
"up_bandwidth": self.up_bandwidth,
"ip": self.ip,
"web_port": self.web_port,
"online_time": self.online_time,
"upstream_traffic": self.upstream_traffic,
"downstream_traffic": self.downstream_traffic,
"pass_time": self.pass_time,
"dev_uuid": self.dev_uuid,
"link_upload_speed": self.link_upload_speed,
"zone": self.zone,
"customer": self.customer,
}
class User(BaseModel, db.Model):
"""Represents Proected users."""
__tablename__ = 'users'
id = db.Column(db.String(45), primary_key=True)
username = db.Column(db.String(64), unique=True)
password_hash = db.Column(db.String(64), comment='加密密文')
nick_name = db.Column(db.String(64))
full_name = db.Column(db.String(64))
type = db.Column(db.String(10), comment='0:administrators,1:member,2:vip')
gender = db.Column(db.String(10), comment='1:man,0:women')
birthday = db.Column(db.DateTime)
address = db.Column(db.Text())
confirmed = db.Column(db.Integer,
default=False,
comment='状态，True->已确认，False->未确认')
# Establish contact with Post's ForeignKey: user_id
posts = db.relationship('Post', backref='users', lazy='dynamic')
roles = db.relationship(
'Role',
secondary=users_roles,
backref=db.backref('users', lazy='dynamic')
#lazy = 'dynamic',
# cascade = 'all, delete-orphan',
# passive_deletes = True
)
mails = db.relationship('Mail', backref='users', lazy='dynamic')
def __init__(self):
self.id = str(uuid4())
def __repr__(self):
"""Define the string format for instance of User."""
return "<Model User `{}`>".format(self.username)
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
"""Convert the password to cryptograph via flask-bcrypt"""
self.password_hash = bcrypt.generate_password_hash(password)
def verify_password(self, password):
return bcrypt.check_password_hash(self.password_hash, password)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'confirm': self.id}).decode('utf-8')
def confirm(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
if data.get('confirm') != self.id:
return False
self.confirmed = True
db.session.add(self)
return True
@property
def actions(self):
"""获取该用户所有的操作权限"""
actions = Action.query.join(roles_actions).join(Role).join(users_roles).join(User).\
filter(User.id == self.id)
return actions
@property
def resources(self):
"""获取该用户所有的菜单权限"""
resources = Resource.query.join(roles_resources).join(Role).join(users_roles).join(User).\
filter(User.id == self.id).order_by(Resource.order).all()
return resources
def check(self, type, action):
# actions = self.actions.filter(Action.code == action).first()
return self.roles is not None and self.actions.filter(
Action.code == action, Action.type == type).first()
def to_json(self):
json_user = {
'id': self.id,
'username': self.username,
'avatar': 'http://127.0.0.1:8089/static/images/user/p1.jpg',
'nick_name': self.nick_name,
'full_name': self.full_name,
'birthday': self.birthday,
'address': self.address,
'status': self.status,
'gender': self.gender,
'create_time': self.created_time,
'emails': [mail.email for mail in self.mails]
# 'email':','.join(self.mails.email)
}
return json_user
@property
def is_authenticated(self):
"""Check the user whether logged in."""
# Check the User's instance whether Class AnonymousUserMixin's instance.
if isinstance(self, AnonymousUserMixin):
return False
else:
return True
@property
def is_active(self):
"""Check the user whether pass the activation process."""
return True
@property
def is_anonymous(self):
"""Check the user's login status whether is anonymous."""
if isinstance(self, AnonymousUserMixin):
return True
else:
return False
def get_id(self):
"""Get the user's uuid from database."""
return self.id
#encoding: utf-8
from uuid import uuid4
import os
from flask import current_app, request, url_for
from flask_login import AnonymousUserMixin, UserMixin
import datetime
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from app.common.db import db
from app.common.extensions import bcrypt
from app.common.time_util import format_date
posts_tags = db.Table(
'posts_tags',
db.Column('id', db.Integer, primary_key=True, autoincrement=True),
db.Column('post_id', db.String(45), db.ForeignKey('posts.id')),
db.Column('tag_id', db.String(45), db.ForeignKey('tags.id')),
db.Column('status', db.Integer))
users_roles = db.Table(
'users_roles',
db.Column('id', db.Integer, primary_key=True, autoincrement=True),
db.Column('user_id', db.String(45), db.ForeignKey('users.id')),
db.Column('role_id', db.String(45), db.ForeignKey('roles.id')),
db.Column('status', db.Integer))
roles_actions = db.Table(
'roles_actions', # 用户权限关联表
db.Column('id', db.Integer, primary_key=True, autoincrement=True),
db.Column('action_id', db.String(45), db.ForeignKey('actions.id')),
db.Column('role_id', db.String(45), db.ForeignKey('roles.id')),
