|
|
from peewee import *
|
|
|
import datetime
|
|
|
from passlib.context import CryptContext
|
|
|
import re
|
|
|
from utils.ClientModels import database_proxy
|
|
|
import logging
|
|
|
|
|
|
# database_proxy = Proxy()
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
# re
|
|
|
USER_RE = re.compile(r"^[a-zA-Z0-9_-]{3,20}$")
|
|
|
PASS_RE = re.compile(r"^.{3,20}$")
|
|
|
|
|
|
# Setting up passlib.
|
|
|
pwd_context = CryptContext(
|
|
|
schemes=["pbkdf2_sha256", ],
|
|
|
default="pbkdf2_sha256",
|
|
|
all__vary_rounds=0.1,
|
|
|
pbkdf2_sha256__default_rounds=20000,
|
|
|
)
|
|
|
|
|
|
class MyBaseModel(Model):
|
|
|
"""
|
|
|
实现一个新的基类，Model是peewee的基类;
|
|
|
新增get_or_none()接口，封装peewee的get()接口，
|
|
|
查询不到返回None，而不抛出异常。
|
|
|
"""
|
|
|
class Meta:
|
|
|
database = database_proxy
|
|
|
|
|
|
is_valid = BooleanField(default=True)
|
|
|
created = TimestampField()
|
|
|
modified = TimestampField()
|
|
|
revision = IntegerField(default=0)
|
|
|
|
|
|
@classmethod
|
|
|
def get_or_none(cls, *args, **kwargs):
|
|
|
try:
|
|
|
return cls.get(*args, **kwargs)
|
|
|
except DoesNotExist:
|
|
|
return None
|
|
|
|
|
|
def save(self, *args, **kwargs):
|
|
|
self.modified = datetime.datetime.now()
|
|
|
self.revision += 1
|
|
|
super(MyBaseModel, self).save(*args, **kwargs)
|
|
|
|
|
|
|
|
|
|
|
|
class User(MyBaseModel):
|
|
|
username = CharField(unique=True)
|
|
|
name = CharField(default='')
|
|
|
password = CharField(default='')
|
|
|
|
|
|
class Meta:
|
|
|
order_by = ('username',)
|
|
|
|
|
|
def crypt_password(self, password):
|
|
|
"""
|
|
|
加密
|
|
|
:param password:
|
|
|
:return: cls.password
|
|
|
"""
|
|
|
self.password = pwd_context.encrypt(password)
|
|
|
return self.password
|
|
|
|
|
|
def verify_password(self, password):
|
|
|
"""
|
|
|
验证密码
|
|
|
:param password:
|
|
|
:return: True/False
|
|
|
"""
|
|
|
return pwd_context.verify(password, self.password)
|
|
|
|
|
|
@classmethod
|
|
|
def username_valid(cls, username):
|
|
|
"""
|
|
|
用户名格式
|
|
|
:param username:
|
|
|
:return: True/False
|
|
|
"""
|
|
|
if USER_RE.match(username):
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
|
|
|
@classmethod
|
|
|
def password_valid(cls, password):
|
|
|
"""
|
|
|
密码格式
|
|
|
:param password:
|
|
|
:return: True/False
|
|
|
"""
|
|
|
if PASS_RE.match(password):
|
|
|
if len(password) < 5 or len(password) > 14:
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
|
|
|
@classmethod
|
|
|
def create_user(cls, username, password, **kwargs):
|
|
|
"""
|
|
|
新建用户
|
|
|
:param username:
|
|
|
:param password:
|
|
|
:param kwargs:
|
|
|
:return: User object
|
|
|
"""
|
|
|
if User.username_valid(username=username):
|
|
|
# 用户名格式
|
|
|
encrypted_username = username
|
|
|
else:
|
|
|
return False
|
|
|
if User.password_valid(password=password):
|
|
|
# 密码格式，且长度大于等于6小于等于14
|
|
|
encrypted_password = pwd_context.encrypt(password)
|
|
|
else:
|
|
|
return False
|
|
|
return User.create(username=encrypted_username, password=encrypted_password, **kwargs)
|
|
|
|
|
|
@classmethod
|
|
|
def get_user(cls, user_id):
|
|
|
"""
|
|
|
根据user_id获取用户
|
|
|
:param user_id:
|
|
|
:return: User object
|
|
|
"""
|
|
|
return cls.get_or_none(cls.id == user_id)
|
|
|
|
|
|
@classmethod
|
|
|
def get_user_by_username(cls, username):
|
|
|
"""
|
|
|
:return: User object
|
|
|
"""
|
|
|
return cls.get_or_none(cls.username == username)
|
|
|
|
|
|
def assign_group(self, group_id):
|
|
|
"""
|
|
|
给用户分配组
|
|
|
:param group_id:
|
|
|
:return: UserGroup object
|
|
|
"""
|
|
|
return UserGroup.add_user_to_group(user_id=self.id, group_id=group_id)
|
|
|
|
|
|
def change_password(self, old_password, new_password):
|
|
|
"""
|
|
|
修改密码
|
|
|
:param old_password:
|
|
|
:param new_password:
|
|
|
:return: 修改成功后保存返回 True,否则返回 False
|
|
|
"""
|
|
|
# invalid format of old password is considered invalid to save processing
|
|
|
if User.password_valid(old_password):
|
|
|
if not self.verify_password(old_password):
|
|
|
return False
|
|
|
# verify new password, format and length
|
|
|
if User.password_valid(new_password):
|
|
|
if old_password == new_password:
|
|
|
return False
|
|
|
else:
|
|
|
self.password = self.crypt_password(password=new_password)
|
|
|
self.save()
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
|
|
|
class Operation(MyBaseModel):
|
|
|
"""
|
|
|
操作表
|
|
|
"""
|
|
|
key = CharField(unique=True)
|
|
|
name = CharField(default='')
|
|
|
parent_key = CharField(default='')
|
|
|
detail = CharField(default='')
|
|
|
level = IntegerField(default=0)
|
|
|
sort = IntegerField(default=0)
|
|
|
|
|
|
@classmethod
|
|
|
def get_operation(cls,name):
|
|
|
return cls.get_or_none(cls.name == name)
|
|
|
|
|
|
@classmethod
|
|
|
def get_operation_id(cls,key):
|
|
|
return cls.get(cls.key == key).id
|
|
|
|
|
|
@classmethod
|
|
|
def create_operation(cls, key, **kwargs):
|
|
|
"""
|
|
|
新加操作
|
|
|
:param key:
|
|
|
:param kwargs:
|
|
|
:return: key/Operation object
|
|
|
"""
|
|
|
operation = cls.get_or_none(cls.key == key)
|
|
|
if operation:
|
|
|
return operation.key
|
|
|
else:
|
|
|
return cls.create(key=key, **kwargs)
|
|
|
|
|
|
def assign_group(self, group_id):
|
|
|
"""
|
|
|
给操作分配组
|
|
|
:param group_id:
|
|
|
:return: GroupOperatePermission object
|
|
|
"""
|
|
|
return GroupOperatePermission.add_operation_to_group(operation_id=self.id, group_id=group_id)
|
|
|
|
|
|
|
|
|
class Group(MyBaseModel):
|
|
|
name = CharField(unique=True)
|
|
|
detail = CharField(default='')
|
|
|
|
|
|
|
|
|
@classmethod
|
|
|
def create_group(cls, name, **kwargs):
|
|
|
"""
|
|
|
新建组
|
|
|
:param name:
|
|
|
:return: name/Group object
|
|
|
"""
|
|
|
group = cls.get_or_none(cls.name == name)
|
|
|
if group:
|
|
|
return group.name
|
|
|
else:
|
|
|
return cls.create(name=name, **kwargs)
|
|
|
|
|
|
@classmethod
|
|
|
def get_group(cls, group_id):
|
|
|
"""
|
|
|
根据group_id获取组
|
|
|
:param group_id:
|
|
|
:return: Group object/None
|
|
|
"""
|
|
|
return cls.get_or_none(cls.id == group_id)
|
|
|
|
|
|
def add_user(self, user_id):
|
|
|
"""
|
|
|
组中添加用户
|
|
|
:param user_id:
|
|
|
:return: UserGroup object
|
|
|
"""
|
|
|
return UserGroup.add_user_to_group(user_id=user_id, group_id=self.id)
|
|
|
|
|
|
def add_operation(self, operation_id):
|
|
|
"""
|
|
|
组中添加操作
|
|
|
:param operation_id:
|
|
|
:return: GroupOperatePermission object
|
|
|
"""
|
|
|
return GroupOperatePermission.add_operation_to_group(operation_id=operation_id, group_id=self.id)
|
|
|
|
|
|
|
|
|
class UserGroup(MyBaseModel):
|
|
|
"""
|
|
|
用户组表
|
|
|
"""
|
|
|
|
|
|
class Meta:
|
|
|
primary_key = CompositeKey('user', 'group')
|
|
|
|
|
|
user = ForeignKeyField(User)
|
|
|
group = ForeignKeyField(Group)
|
|
|
|
|
|
@classmethod
|
|
|
def get_ug_by_group_id(cls, group_id):
|
|
|
"""
|
|
|
根据group_id获取用户组
|
|
|
:param group_id:
|
|
|
:return: UserGroup SelectQuery
|
|
|
"""
|
|
|
return cls.select(UserGroup, Group).join(Group).where(cls.group == group_id)
|
|
|
|
|
|
@classmethod
|
|
|
def get_ug_by_user_id(cls, user_id):
|
|
|
"""
|
|
|
根据user_id获取用户组
|
|
|
:param user_id:
|
|
|
:return: UserGroup SelectQuery
|
|
|
"""
|
|
|
return cls.select(UserGroup, User).join(User).where(cls.user == user_id)
|
|
|
|
|
|
@classmethod
|
|
|
def add_user_to_group(cls, user_id, group_id):
|
|
|
"""
|
|
|
添加用户到组里
|
|
|
:param user_id:
|
|
|
:param group_id:
|
|
|
:return: UserGroup object
|
|
|
"""
|
|
|
if cls.user_is_a_member_of_group(user_id=user_id, group_id=group_id):
|
|
|
return False
|
|
|
else:
|
|
|
return cls.create(user=user_id, group=group_id)
|
|
|
|
|
|
@classmethod
|
|
|
def delete_user_from_group(cls, user_id, group_id):
|
|
|
"""
|
|
|
从组里删除用户
|
|
|
:param user_id:
|
|
|
:param group_id:
|
|
|
:return: None
|
|
|
"""
|
|
|
try:
|
|
|
ug = cls.get(cls.user == user_id, cls.group == group_id)
|
|
|
return ug.delete_instance()
|
|
|
except UserGroup.DoesNotExist:
|
|
|
return False
|
|
|
|
|
|
@classmethod
|
|
|
def user_is_a_member_of_group(cls, user_id, group_id):
|
|
|
"""
|
|
|
用户是否是组的成员
|
|
|
:param user_id:
|
|
|
:param group_id:
|
|
|
:return: True/False
|
|
|
"""
|
|
|
query = cls.select().where(cls.user == user_id, cls.group == group_id)
|
|
|
if len(query) == 0:
|
|
|
return False
|
|
|
elif len(query) == 1:
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
|
|
|
@classmethod
|
|
|
def get_groups_of_user(cls, user_id):
|
|
|
"""
|
|
|
获取用户所属的所有组
|
|
|
:param user_id:
|
|
|
:return: lists
|
|
|
"""
|
|
|
lists = []
|
|
|
ugs = cls.get_ug_by_user_id(user_id=user_id)
|
|
|
for ug in ugs:
|
|
|
lists.append(ug.group.name)
|
|
|
return lists
|
|
|
|
|
|
@classmethod
|
|
|
def get_users_in_group(cls, group_id):
|
|
|
"""
|
|
|
获取组中所有的用户
|
|
|
:param group_id:
|
|
|
:return: lists
|
|
|
"""
|
|
|
lists = []
|
|
|
ugs = cls.get_ug_by_group_id(group_id=group_id)
|
|
|
for ug in ugs:
|
|
|
lists.append(ug.user.username)
|
|
|
return lists
|
|
|
|
|
|
|
|
|
class GroupOperatePermission(MyBaseModel):
|
|
|
"""
|
|
|
授权表
|
|
|
"""
|
|
|
|
|
|
class Meta:
|
|
|
primary_key = CompositeKey('group', 'operation')
|
|
|
|
|
|
group = ForeignKeyField(Group)
|
|
|
operation = ForeignKeyField(Operation)
|
|
|
|
|
|
@classmethod
|
|
|
def get_gop_by_group_id(cls, group_id):
|
|
|
"""
|
|
|
根据group_id获取授权表
|
|
|
:param group_id:
|
|
|
:return: GroupOperatePermission SelectQuery
|
|
|
"""
|
|
|
return cls.select(GroupOperatePermission, Group).join(Group).where(cls.group == group_id)
|
|
|
|
|
|
@classmethod
|
|
|
def get_gop_by_operation_id(cls, operation_id):
|
|
|
"""
|
|
|
根据operation_id获取授权表
|
|
|
:param operation_id:
|
|
|
:return: GroupOperatePermission SelectQuery
|
|
|
"""
|
|
|
return cls.select(GroupOperatePermission, Operation).join(Operation).where(cls.operation == operation_id)
|
|
|
|
|
|
@classmethod
|
|
|
def add_operation_to_group(cls, operation_id, group_id):
|
|
|
"""
|
|
|
增加操作到组
|
|
|
:param operation_id:
|
|
|
:param group_id:
|
|
|
:return: GroupOperatePermission object
|
|
|
"""
|
|
|
if cls.operation_is_a_member_of_group(operation_id=operation_id, group_id=group_id):
|
|
|
return False
|
|
|
else:
|
|
|
return cls.create(operation=operation_id, group=group_id)
|
|
|
|
|
|
@classmethod
|
|
|
def delete_operation_from_group(cls, operation_id, group_id):
|
|
|
"""
|
|
|
从组中删除操作
|
|
|
:param operation_id:
|
|
|
:param group_id:
|
|
|
:return: None/False
|
|
|
"""
|
|
|
try:
|
|
|
gop = cls.get(cls.operation == operation_id, cls.group == group_id)
|
|
|
return gop.delete_instance()
|
|
|
except GroupOperatePermission.DoesNotExist:
|
|
|
return False
|
|
|
|
|
|
@classmethod
|
|
|
def operation_is_a_member_of_group(cls, operation_id, group_id):
|
|
|
"""
|
|
|
判断成员
|
|
|
:param operation_id:
|
|
|
:param group_id:
|
|
|
:return: True/False
|
|
|
"""
|
|
|
query = cls.select().where(cls.operation == operation_id, cls.group == group_id)
|
|
|
if len(query) == 0:
|
|
|
return False
|
|
|
elif len(query) == 1:
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
|
|
|
@classmethod
|
|
|
def get_groups_with_operation(cls, operation_id):
|
|
|
"""
|
|
|
获取拥有某个操作的所有组
|
|
|
:param operation_id:
|
|
|
:return: lists
|
|
|
"""
|
|
|
lists = []
|
|
|
gops = cls.get_gop_by_operation_id(operation_id=operation_id)
|
|
|
for gop in gops:
|
|
|
lists.append(gop.group.name)
|
|
|
return lists
|
|
|
|
|
|
@classmethod
|
|
|
def get_operations_of_group(cls, group_id):
|
|
|
"""
|
|
|
获取某一个组中所有的操作
|
|
|
:param group_id:
|
|
|
:return: lists
|
|
|
"""
|
|
|
lists = []
|
|
|
gops = cls.get_gop_by_group_id(group_id=group_id)
|
|
|
for gop in gops:
|
|
|
lists.append(gop.operation.name)
|
|
|
return lists
|
|
|
|
|
|
def getPermission(userName):
|
|
|
try:
|
|
|
userId = User.get_user_by_username(userName).id
|
|
|
groupId = UserGroup.get_ug_by_user_id(userId)[0].group
|
|
|
permissionList = GroupOperatePermission.get_operations_of_group(groupId)
|
|
|
except:
|
|
|
return None
|
|
|
return permissionList |