mirror of
https://github.com/tencentmusic/cube-studio.git
synced 2024-12-21 06:19:31 +08:00
886 lines
30 KiB
Python
886 lines
30 KiB
Python
from flask_login import current_user
|
||
import logging
|
||
import jwt
|
||
|
||
from flask_babel import lazy_gettext
|
||
import pysnooper
|
||
from flask import current_app
|
||
from flask_appbuilder.security.sqla import models as ab_models
|
||
from flask_appbuilder.security.sqla.manager import SecurityManager
|
||
from flask_babel import lazy_gettext as _
|
||
from flask_appbuilder.security.views import (
|
||
PermissionModelView,
|
||
PermissionViewModelView,
|
||
RoleModelView,
|
||
UserModelView
|
||
)
|
||
from flask_appbuilder.security.sqla.models import assoc_user_role
|
||
|
||
from flask_appbuilder.security.decorators import has_access
|
||
from flask_appbuilder.models.sqla.interface import SQLAInterface
|
||
from flask_appbuilder.widgets import ListWidget
|
||
from sqlalchemy import or_
|
||
|
||
from flask_appbuilder.security.views import expose
|
||
|
||
from flask import g, flash, request
|
||
|
||
from flask_appbuilder.security.sqla.models import assoc_permissionview_role
|
||
from sqlalchemy import select
|
||
from flask_appbuilder.const import (
|
||
AUTH_DB,
|
||
AUTH_LDAP,
|
||
AUTH_OAUTH,
|
||
AUTH_OID,
|
||
AUTH_REMOTE_USER,
|
||
LOGMSG_WAR_SEC_LOGIN_FAILED
|
||
)
|
||
|
||
|
||
|
||
|
||
# user list page template
|
||
class MyappSecurityListWidget(ListWidget):
|
||
"""
|
||
Redeclaring to avoid circular imports
|
||
"""
|
||
template = "myapp/fab_overrides/list.html"
|
||
|
||
|
||
# role list page template
|
||
class MyappRoleListWidget(ListWidget):
|
||
"""
|
||
Role model view from FAB already uses a custom list widget override
|
||
So we override the override
|
||
"""
|
||
template = "myapp/fab_overrides/list_role.html"
|
||
def __init__(self, **kwargs):
|
||
kwargs["appbuilder"] = current_app.appbuilder
|
||
super().__init__(**kwargs)
|
||
|
||
|
||
|
||
# customize list,add,edit page
|
||
UserModelView.list_columns= ["username", "active", "roles"]
|
||
UserModelView.edit_columns= ["first_name", "last_name", "username", "active", "email"]
|
||
UserModelView.add_columns= ["first_name", "last_name", "username", "email", "active", "roles"]
|
||
|
||
|
||
|
||
UserModelView.list_widget = MyappSecurityListWidget
|
||
RoleModelView.list_widget = MyappRoleListWidget
|
||
PermissionViewModelView.list_widget = MyappSecurityListWidget
|
||
PermissionModelView.list_widget = MyappSecurityListWidget
|
||
|
||
|
||
# expand user
|
||
from flask_appbuilder.security.sqla.models import User,Role
|
||
from sqlalchemy import Column, String
|
||
|
||
|
||
|
||
class MyUser(User):
|
||
__tablename__ = 'ab_user'
|
||
org = Column(String(200)) # Organization
|
||
def get_full_name(self):
|
||
return self.username
|
||
|
||
def __repr__(self):
|
||
return self.username
|
||
|
||
def is_admin(self):
|
||
user_roles = [role.name.lower() for role in list(self.roles)]
|
||
if "admin" in user_roles:
|
||
return True
|
||
return False
|
||
|
||
@property
|
||
def secret(self):
|
||
if self.changed_on:
|
||
pass
|
||
# help(self.changed_on)
|
||
# timestamp = int(func.date_format(self.changed_on))
|
||
timestamp = int(self.changed_on.timestamp())
|
||
payload = {
|
||
"iss": self.username
|
||
# "iat": timestamp, # Issue period
|
||
# "nbf": timestamp, # Effective Date
|
||
# "exp": timestamp + 60 * 60 * 24 * 30 * 12, # Valid for 12 months
|
||
}
|
||
|
||
global_password = 'myapp'
|
||
encoded_jwt = jwt.encode(payload, global_password, algorithm='HS256')
|
||
return encoded_jwt
|
||
return ''
|
||
|
||
|
||
# customize role view
|
||
class MyRoleModelView(RoleModelView):
|
||
|
||
datamodel = SQLAInterface(Role)
|
||
order_columns = ["id"]
|
||
route_base = "/roles"
|
||
list_columns = ["name", "permissions"]
|
||
|
||
|
||
class MyUserRemoteUserModelView_Base():
|
||
datamodel = SQLAInterface(MyUser)
|
||
list_columns = ["username", "active", "roles", ]
|
||
edit_columns = ["first_name", "last_name", "username",'password', "active", "email", "roles",'org' ]
|
||
add_columns = ["first_name", "last_name", "username",'password', "active", "email", "roles",'org' ]
|
||
show_columns = ["username", "active", "roles", "login_count"]
|
||
list_widget = MyappSecurityListWidget
|
||
label_columns = {
|
||
"get_full_name": lazy_gettext("Full Name"),
|
||
"first_name": lazy_gettext("First Name"),
|
||
"last_name": lazy_gettext("Last Name"),
|
||
"username": lazy_gettext("User Name"),
|
||
"password": lazy_gettext("Password"),
|
||
"active": lazy_gettext("Is Active?"),
|
||
"email": lazy_gettext("Email"),
|
||
"roles": lazy_gettext("Role"),
|
||
"last_login": lazy_gettext("Last login"),
|
||
"login_count": lazy_gettext("Login count"),
|
||
"fail_login_count": lazy_gettext("Failed login count"),
|
||
"created_on": lazy_gettext("Created on"),
|
||
"created_by": lazy_gettext("Created by"),
|
||
"changed_on": lazy_gettext("Changed on"),
|
||
"changed_by": lazy_gettext("Changed by"),
|
||
"secret": lazy_gettext("Authorization"),
|
||
}
|
||
|
||
show_fieldsets = [
|
||
(
|
||
lazy_gettext("User info"),
|
||
{"fields": ["username", "active", "roles", "login_count",'secret']},
|
||
),
|
||
(
|
||
lazy_gettext("Personal Info"),
|
||
{"fields": ["first_name", "last_name", "email",'org'], "expanded": True},
|
||
),
|
||
(
|
||
lazy_gettext("Audit Info"),
|
||
{
|
||
"fields": [
|
||
"last_login",
|
||
"fail_login_count",
|
||
"created_on",
|
||
"created_by",
|
||
"changed_on",
|
||
"changed_by",
|
||
],
|
||
"expanded": False,
|
||
},
|
||
),
|
||
]
|
||
|
||
user_show_fieldsets = [
|
||
(
|
||
lazy_gettext("User info"),
|
||
{"fields": ["username", "active", "roles", "login_count",'secret']},
|
||
),
|
||
(
|
||
lazy_gettext("Personal Info"),
|
||
{"fields": ["first_name", "last_name", "email"], "expanded": True},
|
||
),
|
||
]
|
||
|
||
|
||
@expose("/userinfo/")
|
||
@has_access
|
||
def userinfo(self):
|
||
item = self.datamodel.get(g.user.id, self._base_filters)
|
||
widgets = self._get_show_widget(
|
||
g.user.id, item, show_fieldsets=self.user_show_fieldsets
|
||
)
|
||
self.update_redirect()
|
||
return self.render_template(
|
||
self.show_template,
|
||
title=self.user_info_title,
|
||
widgets=widgets,
|
||
appbuilder=self.appbuilder,
|
||
)
|
||
|
||
# 添加默认gamma角色
|
||
# @pysnooper.snoop()
|
||
def post_add(self,user):
|
||
from myapp import security_manager,db
|
||
gamma_role = security_manager.find_role('Gamma')
|
||
if gamma_role not in user.roles:
|
||
user.roles.append(gamma_role)
|
||
db.session.commit()
|
||
|
||
# 添加到public项目组
|
||
try:
|
||
from myapp.models.model_team import Project_User, Project
|
||
public_project = db.session.query(Project).filter(Project.name == "public").filter(Project.type == "org").first()
|
||
if public_project:
|
||
project_user = Project_User()
|
||
project_user.project = public_project
|
||
project_user.role = 'dev'
|
||
project_user.user_id = user.id
|
||
db.session.add(project_user)
|
||
db.session.commit()
|
||
except Exception:
|
||
db.session.rollback()
|
||
|
||
|
||
|
||
class MyUserRemoteUserModelView(MyUserRemoteUserModelView_Base,UserModelView):
|
||
datamodel = SQLAInterface(MyUser)
|
||
|
||
from flask_appbuilder.security.views import SimpleFormView
|
||
from flask_appbuilder._compat import as_unicode
|
||
from flask_babel import lazy_gettext
|
||
from wtforms import StringField
|
||
from wtforms.validators import DataRequired
|
||
|
||
from flask_appbuilder.fieldwidgets import BS3TextFieldWidget
|
||
from flask_appbuilder.forms import DynamicForm
|
||
|
||
|
||
class UserInfoEditView(SimpleFormView):
|
||
|
||
class UserInfoEdit(DynamicForm):
|
||
first_name = StringField(
|
||
lazy_gettext("First Name"),
|
||
validators=[DataRequired()],
|
||
widget=BS3TextFieldWidget(),
|
||
description=lazy_gettext("Write the user first name or names"),
|
||
)
|
||
last_name = StringField(
|
||
lazy_gettext("Last Name"),
|
||
validators=[DataRequired()],
|
||
widget=BS3TextFieldWidget(),
|
||
description=lazy_gettext("Write the user last name"),
|
||
)
|
||
username = StringField(
|
||
lazy_gettext("User Name"),
|
||
validators=[DataRequired()],
|
||
widget=BS3TextFieldWidget(),
|
||
description=lazy_gettext("Write the Username"),
|
||
)
|
||
password = StringField(
|
||
lazy_gettext("Password"),
|
||
validators=[DataRequired()],
|
||
widget=BS3TextFieldWidget(),
|
||
description=lazy_gettext("Password"),
|
||
)
|
||
email = StringField(
|
||
lazy_gettext("Email"),
|
||
validators=[DataRequired()],
|
||
widget=BS3TextFieldWidget(),
|
||
description=lazy_gettext("Write the Email"),
|
||
)
|
||
org = StringField(
|
||
lazy_gettext("Org"),
|
||
widget=BS3TextFieldWidget(),
|
||
description=lazy_gettext("organization name"),
|
||
)
|
||
|
||
form = UserInfoEdit
|
||
form_title = lazy_gettext("Edit User Information")
|
||
redirect_url = "/"
|
||
message = lazy_gettext("User information changed")
|
||
|
||
def form_get(self, form):
|
||
item = self.appbuilder.sm.get_user_by_id(g.user.id)
|
||
# fills the form generic solution
|
||
for key, value in form.data.items():
|
||
if key == "csrf_token":
|
||
continue
|
||
form_field = getattr(form, key)
|
||
form_field.data = getattr(item, key)
|
||
|
||
def form_post(self, form):
|
||
form = self.form.refresh(request.form)
|
||
item = self.appbuilder.sm.get_user_by_id(g.user.id)
|
||
form.populate_obj(item)
|
||
self.appbuilder.sm.update_user(item)
|
||
flash(as_unicode(self.message), "info")
|
||
|
||
|
||
|
||
from myapp.project import MyCustomRemoteUserView
|
||
from myapp.project import Myauthdbview
|
||
# myapp自带的角色和角色权限，自定义了各种权限
|
||
# 基础类fab-Security-Manager中 def load_user(self, pk): 是用来认证用户的
|
||
# before_request是user赋值给g.user
|
||
# @pysnooper.snoop()
|
||
class MyappSecurityManager(SecurityManager):
|
||
|
||
user_model = MyUser
|
||
rolemodelview = MyRoleModelView #
|
||
|
||
# Remote Authentication
|
||
userremoteusermodelview = MyUserRemoteUserModelView
|
||
authremoteuserview = MyCustomRemoteUserView
|
||
|
||
# Account password authentication
|
||
userdbmodelview = MyUserRemoteUserModelView
|
||
authdbview = Myauthdbview
|
||
|
||
# userinfo edit view
|
||
userinfoeditview = UserInfoEditView
|
||
|
||
# 构建启动前工作，认证
|
||
@staticmethod
|
||
def before_request():
|
||
g.user = current_user
|
||
|
||
def __init__(self, appbuilder):
|
||
super(MyappSecurityManager, self).__init__(appbuilder)
|
||
# 添加从header中进行认证的方式
|
||
self.lm.header_loader(self.load_user_from_header)
|
||
|
||
# 使用header 认证，通过rtx名获取用户
|
||
# @pysnooper.snoop()
|
||
def load_user_from_header(self, authorization_value):
|
||
# token=None
|
||
# if 'token' in request.headers:
|
||
# token = request.headers['token']
|
||
if authorization_value:
|
||
# rtx 免认证
|
||
if len(authorization_value) < 20:
|
||
username = authorization_value
|
||
if username:
|
||
user = self.find_user(username)
|
||
g.user = user
|
||
return user
|
||
else: # token 认证
|
||
encoded_jwt = authorization_value.encode('utf-8')
|
||
payload = jwt.decode(encoded_jwt, 'myapp', algorithms=['HS256'])
|
||
# if payload['iat'] > time.time():
|
||
# return
|
||
# elif payload['exp'] < time.time():
|
||
# return
|
||
# else:
|
||
user = self.find_user(payload['iss'])
|
||
g.user = user
|
||
return user
|
||
|
||
# 自定义登录用户
|
||
def load_user(self, pk):
|
||
user = self.get_user_by_id(int(pk))
|
||
# set cookie
|
||
return user
|
||
|
||
|
||
# 注册security菜单栏下的子菜单和链接
|
||
# @pysnooper.snoop()
|
||
def register_views(self):
|
||
if not self.appbuilder.app.config.get('FAB_ADD_SECURITY_VIEWS', True):
|
||
return
|
||
# Security APIs
|
||
self.appbuilder.add_api(self.security_api)
|
||
|
||
if self.auth_user_registration:
|
||
if self.auth_type == AUTH_DB:
|
||
self.registeruser_view = self.registeruserdbview()
|
||
elif self.auth_type == AUTH_OID:
|
||
self.registeruser_view = self.registeruseroidview()
|
||
elif self.auth_type == AUTH_OAUTH:
|
||
self.registeruser_view = self.registeruseroauthview()
|
||
if self.registeruser_view:
|
||
self.appbuilder.add_view_no_menu(self.registeruser_view)
|
||
|
||
self.appbuilder.add_view_no_menu(self.resetpasswordview())
|
||
self.appbuilder.add_view_no_menu(self.resetmypasswordview())
|
||
self.appbuilder.add_view_no_menu(self.userinfoeditview())
|
||
|
||
|
||
|
||
if self.auth_type == AUTH_DB:
|
||
self.user_view = self.userdbmodelview
|
||
self.auth_view = self.authdbview()
|
||
|
||
elif self.auth_type == AUTH_LDAP:
|
||
self.user_view = self.userldapmodelview
|
||
self.auth_view = self.authldapview()
|
||
elif self.auth_type == AUTH_OAUTH:
|
||
self.user_view = self.useroauthmodelview
|
||
self.auth_view = self.authoauthview()
|
||
elif self.auth_type == AUTH_REMOTE_USER:
|
||
self.user_view = self.userremoteusermodelview
|
||
self.auth_view = self.authremoteuserview()
|
||
else:
|
||
self.user_view = self.useroidmodelview
|
||
self.auth_view = self.authoidview()
|
||
if self.auth_user_registration:
|
||
pass
|
||
self.registeruser_view = self.registeruseroidview()
|
||
self.appbuilder.add_view_no_menu(self.registeruser_view)
|
||
|
||
|
||
self.appbuilder.add_view_no_menu(self.auth_view)
|
||
|
||
self.user_view = self.appbuilder.add_view(
|
||
self.user_view,
|
||
"List Users",
|
||
icon="fa-user",
|
||
href="/users/list/?_flt_2_username=",
|
||
label=_("List Users"),
|
||
category="Security",
|
||
category_icon="fa-cogs",
|
||
category_label=_("Security"),
|
||
)
|
||
role_view = self.appbuilder.add_view(
|
||
self.rolemodelview,
|
||
"List Roles",
|
||
icon="fa-group",
|
||
href="/roles/list/?_flt_2_name=",
|
||
label=_("List Roles"),
|
||
category="Security",
|
||
category_icon="fa-cogs",
|
||
)
|
||
role_view.related_views = [self.user_view.__class__]
|
||
|
||
if self.userstatschartview:
|
||
self.appbuilder.add_view(
|
||
self.userstatschartview,
|
||
"User's Statistics",
|
||
icon="fa-bar-chart-o",
|
||
label=_("User's Statistics"),
|
||
category="Security",
|
||
)
|
||
if self.auth_user_registration:
|
||
self.appbuilder.add_view(
|
||
self.registerusermodelview,
|
||
"User's Statistics",
|
||
icon="fa-user-plus",
|
||
label=_("User Registrations"),
|
||
category="Security",
|
||
)
|
||
self.appbuilder.menu.add_separator("Security")
|
||
self.appbuilder.add_view(
|
||
self.permissionmodelview,
|
||
"Base Permissions",
|
||
icon="fa-lock",
|
||
label=_("Base Permissions"),
|
||
category="Security",
|
||
)
|
||
self.appbuilder.add_view(
|
||
self.viewmenumodelview,
|
||
"Views/Menus",
|
||
icon="fa-list-alt",
|
||
label=_("Views/Menus"),
|
||
category="Security",
|
||
)
|
||
self.appbuilder.add_view(
|
||
self.permissionviewmodelview,
|
||
"Permission on Views/Menus",
|
||
icon="fa-link",
|
||
label=_("Permission on Views/Menus"),
|
||
category="Security",
|
||
)
|
||
|
||
|
||
# @pysnooper.snoop()
|
||
def add_org_user(self,username,first_name,last_name,org,email,roles,password="",hashed_password=""):
|
||
"""
|
||
Generic function to create user
|
||
"""
|
||
try:
|
||
user = self.user_model()
|
||
user.first_name = first_name
|
||
user.org = org
|
||
user.last_name = last_name
|
||
user.username = username
|
||
user.email = email
|
||
user.active = True
|
||
user.roles+=roles # 添加默认注册角色
|
||
user.password=password
|
||
# if hashed_password:
|
||
# user.password = hashed_password
|
||
# else:
|
||
# user.password = generate_password_hash(password)
|
||
self.get_session.add(user)
|
||
self.get_session.commit()
|
||
|
||
try:
|
||
from myapp.models.model_team import Project_User, Project
|
||
public_project = self.get_session.query(Project).filter(Project.name == "public").filter(Project.type == "org").first()
|
||
if public_project:
|
||
project_user = Project_User()
|
||
project_user.project = public_project
|
||
project_user.role = 'dev'
|
||
project_user.user_id = user.id
|
||
self.get_session.add(project_user)
|
||
self.get_session.commit()
|
||
except Exception:
|
||
self.get_session.rollback()
|
||
|
||
return user
|
||
except Exception:
|
||
self.get_session.rollback()
|
||
return False
|
||
|
||
# 添加public项目组
|
||
|
||
|
||
|
||
# 添加注册远程用户
|
||
# @pysnooper.snoop()
|
||
def auth_user_remote_org_user(self, username,org_name='',password='',email='',first_name='',last_name=''):
|
||
if not username:
|
||
return None
|
||
# 查找用户
|
||
user = self.find_user(username=username)
|
||
# 添加以组织同名的角色，同时添加上级角色
|
||
# # 注册rtx同名角色
|
||
# rtx_role = self.add_role(username)
|
||
# 如果用户不存在就注册用户
|
||
if user is None:
|
||
user = self.add_org_user(
|
||
username=username,
|
||
first_name=first_name if first_name else username,
|
||
last_name=last_name if last_name else username,
|
||
password=password,
|
||
org=org_name, # 添加组织架构
|
||
email=username + "@cube-studio.com" if not email else email,
|
||
roles=[self.find_role(self.auth_user_registration_role)] if self.find_role(self.auth_user_registration_role) else [] # org_role 添加gamma默认角色, 组织架构角色先不自动添加
|
||
)
|
||
elif not user.is_active: # 如果用户未激活不允许接入
|
||
print(LOGMSG_WAR_SEC_LOGIN_FAILED.format(username))
|
||
return None
|
||
if user:
|
||
user.org = org_name if org_name else user.org
|
||
user.email = email if email else user.email
|
||
user.first_name = first_name if first_name else user.first_name
|
||
user.last_name = last_name if last_name else user.last_name
|
||
|
||
gamma_role = self.find_role(self.auth_user_registration_role)
|
||
if gamma_role and gamma_role not in user.roles:
|
||
user.roles.append(gamma_role)
|
||
# if rtx_role and rtx_role not in user.roles:
|
||
# user.roles.append(rtx_role)
|
||
# 更新用户信息
|
||
if org_name:
|
||
user.org = org_name # 更新组织架构字段
|
||
# org_role = self.add_role(org_name)
|
||
# if org_role not in user.roles:
|
||
# user.roles.append(org_role)
|
||
|
||
self.update_user_auth_stat(user)
|
||
|
||
return user
|
||
|
||
|
||
|
||
READ_ONLY_MODEL_VIEWS = {
|
||
'link','Minio','Kubernetes Dashboard','Granfana','Wiki'
|
||
}
|
||
|
||
|
||
USER_MODEL_VIEWS = {
|
||
"UserDBModelView",
|
||
"UserLDAPModelView",
|
||
"UserOAuthModelView",
|
||
"UserOIDModelView",
|
||
"UserRemoteUserModelView",
|
||
}
|
||
|
||
|
||
# 只有admin才能看到的menu
|
||
ADMIN_ONLY_VIEW_MENUS = {
|
||
"ResetPasswordView",
|
||
"RoleModelView",
|
||
"List Users",
|
||
"List Roles",
|
||
"UserStatsChartView",
|
||
"Base Permissions",
|
||
"Permission on Views/Menus",
|
||
"Action Log",
|
||
"Views/Menus",
|
||
"ViewMenuModelView",
|
||
"User's Statistics",
|
||
"Security",
|
||
} | USER_MODEL_VIEWS
|
||
|
||
ALPHA_ONLY_VIEW_MENUS = {}
|
||
# 只有admin才有的权限
|
||
ADMIN_ONLY_PERMISSIONS = {
|
||
"can_override_role_permissions",
|
||
"can_override_role_permissions",
|
||
# "can_approve", # db owner需要授权approve 权限后才能授权
|
||
"can_update_role",
|
||
}
|
||
|
||
READ_ONLY_PERMISSION = {"can_show", "can_list",'can_add'}
|
||
|
||
ALPHA_ONLY_PERMISSIONS = {
|
||
"muldelete"
|
||
}
|
||
|
||
# 用户创建menu才有的权限
|
||
OBJECT_SPEC_PERMISSIONS = {
|
||
"can_only_access_owned_queries",
|
||
}
|
||
|
||
# 所有人都可以有的基本权限
|
||
ACCESSIBLE_PERMS = {"can_userinfo","can_request_access","can_approve"}
|
||
|
||
# 获取用户是否有在指定视图上的指定权限名
|
||
# @pysnooper.snoop()
|
||
def can_access(self, permission_name, view_name):
|
||
"""Protecting from has_access failing from missing perms/view"""
|
||
user = g.user
|
||
if user.is_anonymous:
|
||
return self.is_item_public(permission_name, view_name)
|
||
return self._has_view_access(user, permission_name, view_name)
|
||
|
||
|
||
|
||
# 获取用户具有指定权限的视图
|
||
def user_view_menu_names(self, permission_name: str):
|
||
from myapp import db
|
||
base_query = (
|
||
db.session.query(self.viewmenu_model.name)
|
||
.join(self.permissionview_model)
|
||
.join(self.permission_model)
|
||
.join(assoc_permissionview_role)
|
||
.join(self.role_model)
|
||
)
|
||
|
||
# 非匿名用户
|
||
if not g.user.is_anonymous:
|
||
# filter by user id
|
||
view_menu_names = (
|
||
base_query.join(assoc_user_role)
|
||
.join(self.user_model)
|
||
.filter(self.user_model.id == g.user.id)
|
||
.filter(self.permission_model.name == permission_name)
|
||
).all()
|
||
return set([s.name for s in view_menu_names])
|
||
|
||
# Properly treat anonymous user 匿名用户
|
||
public_role = self.get_public_role()
|
||
if public_role:
|
||
# filter by public role
|
||
view_menu_names = (
|
||
base_query.filter(self.role_model.id == public_role.id).filter(
|
||
self.permission_model.name == permission_name
|
||
)
|
||
).all()
|
||
return set([s.name for s in view_menu_names])
|
||
return set()
|
||
|
||
|
||
# 在视图上添加权限
|
||
def merge_perm(self, permission_name, view_menu_name):
|
||
logging.warning(
|
||
"This method 'merge_perm' is deprecated use add_permission_view_menu"
|
||
)
|
||
self.add_permission_view_menu(permission_name, view_menu_name)
|
||
|
||
# 判断权限是否是user自定义权限
|
||
def is_user_defined_permission(self, perm):
|
||
return perm.permission.name in self.OBJECT_SPEC_PERMISSIONS
|
||
|
||
|
||
|
||
|
||
# 初始化自定义角色，将对应的权限加到对应的角色上
|
||
# @pysnooper.snoop()
|
||
def sync_role_definitions(self):
|
||
"""Inits the Myapp application with security roles and such"""
|
||
|
||
logging.info("Syncing role definition")
|
||
|
||
# Creating default roles
|
||
self.set_role("Admin", self.is_admin_pvm)
|
||
self.set_role("Gamma", self.is_gamma_pvm)
|
||
|
||
|
||
# commit role and view menu updates
|
||
self.get_session.commit()
|
||
self.clean_perms()
|
||
|
||
# 清理权限
|
||
def clean_perms(self):
|
||
"""FAB leaves faulty permissions that need to be cleaned up"""
|
||
logging.info("Cleaning faulty perms")
|
||
sesh = self.get_session
|
||
pvms = sesh.query(ab_models.PermissionView).filter(
|
||
or_(
|
||
ab_models.PermissionView.permission == None, # NOQA
|
||
ab_models.PermissionView.view_menu == None, # NOQA
|
||
)
|
||
)
|
||
deleted_count = pvms.delete()
|
||
sesh.commit()
|
||
if deleted_count:
|
||
logging.info("Deleted {} faulty permissions".format(deleted_count))
|
||
|
||
# 为角色添加权限，pvm_check为自定义权限校验函数。这样变量权限，就能通过pvm_check函数知道时候应该把权限加到角色上
|
||
def set_role(self, role_name, pvm_check):
|
||
logging.info("Syncing {} perms".format(role_name))
|
||
sesh = self.get_session
|
||
# 获取所有的pv记录
|
||
pvms = sesh.query(ab_models.PermissionView).all()
|
||
# 获取权限和视图都有值的pv
|
||
pvms = [p for p in pvms if p.permission and p.view_menu]
|
||
# 添加或者获取role
|
||
role = self.add_role(role_name)
|
||
# 检查pv是否归属于该role
|
||
role_pvms = [p for p in pvms if pvm_check(p)]
|
||
role.permissions = role_pvms
|
||
# 添加pv-role记录
|
||
sesh.merge(role)
|
||
sesh.commit()
|
||
|
||
# 看一个权限是否是只有admin角色该有的权限
|
||
def is_admin_only(self, pvm):
|
||
# not readonly operations on read only model views allowed only for admins
|
||
if (
|
||
pvm.view_menu.name in self.READ_ONLY_MODEL_VIEWS
|
||
and pvm.permission.name not in self.READ_ONLY_PERMISSION
|
||
):
|
||
return True
|
||
return (
|
||
pvm.view_menu.name in self.ADMIN_ONLY_VIEW_MENUS
|
||
or pvm.permission.name in self.ADMIN_ONLY_PERMISSIONS
|
||
)
|
||
|
||
|
||
# 校验权限是否是默认所有人可接受的
|
||
def is_accessible_to_all(self, pvm):
|
||
return pvm.permission.name in self.ACCESSIBLE_PERMS
|
||
|
||
# 看一个权限是否是admin角色该有的权限
|
||
def is_admin_pvm(self, pvm):
|
||
return not self.is_user_defined_permission(pvm)
|
||
|
||
# 看一个权限是否是gamma角色该有的权限
|
||
def is_gamma_pvm(self, pvm):
|
||
return not (
|
||
self.is_user_defined_permission(pvm)
|
||
or self.is_admin_only(pvm)
|
||
) or self.is_accessible_to_all(pvm)
|
||
|
||
|
||
# 创建视图，创建权限，创建视图-权限绑定记录。
|
||
def set_perm(self, mapper, connection, target,permission_name): # noqa
|
||
#
|
||
# connection is sql
|
||
# target is tables/db model
|
||
|
||
if target.perm != target.get_perm():
|
||
link_table = target.__table__
|
||
connection.execute(
|
||
link_table.update()
|
||
.where(link_table.c.id == target.id)
|
||
.values(perm=target.get_perm())
|
||
)
|
||
|
||
# add to view menu if not already exists
|
||
permission_name = permission_name
|
||
view_menu_name = target.get_perm()
|
||
permission = self.find_permission(permission_name)
|
||
view_menu = self.find_view_menu(view_menu_name)
|
||
pv = None
|
||
# 如果权限不存存在就创建
|
||
if not permission:
|
||
permission_table = (
|
||
self.permission_model.__table__ # pylint: disable=no-member
|
||
)
|
||
connection.execute(permission_table.insert().values(name=permission_name))
|
||
permission = self.find_permission(permission_name)
|
||
|
||
# 如果视图不存在就创建
|
||
if not view_menu:
|
||
view_menu_table = self.viewmenu_model.__table__ # pylint: disable=no-member
|
||
connection.execute(view_menu_table.insert().values(name=view_menu_name))
|
||
view_menu = self.find_view_menu(view_menu_name)
|
||
|
||
# 获取是否存在 视图-权限绑定 记录
|
||
if permission and view_menu:
|
||
pv = (
|
||
self.get_session.query(self.permissionview_model)
|
||
.filter_by(permission=permission, view_menu=view_menu)
|
||
.first()
|
||
)
|
||
|
||
# 如果没有视图-权限绑定 记录，就创建
|
||
if not pv and permission and view_menu:
|
||
permission_view_table = (
|
||
self.permissionview_model.__table__ # pylint: disable=no-member
|
||
)
|
||
connection.execute(
|
||
permission_view_table.insert().values(
|
||
permission_id=permission.id, view_menu_id=view_menu.id
|
||
)
|
||
)
|
||
# 重新获取权限视图绑定记录
|
||
pv = (
|
||
self.get_session.query(self.permissionview_model)
|
||
.filter_by(permission=permission, view_menu=view_menu)
|
||
.first()
|
||
)
|
||
return pv
|
||
|
||
|
||
|
||
# 根据权限，视图，添加到相关pv-role
|
||
@classmethod
|
||
def add_pv_role(self,permission_name,view_menu_name,session):
|
||
permission = session.query(self.permission_model).filter_by(name=permission_name).first()
|
||
view_menu = session.query(self.viewmenu_model).filter_by(name=view_menu_name).first()
|
||
# 获取是否存在 视图-权限绑定 记录
|
||
if permission and view_menu:
|
||
pv = (
|
||
session.query(self.permissionview_model)
|
||
.filter_by(permission=permission, view_menu=view_menu)
|
||
.first()
|
||
)
|
||
try:
|
||
# 为用户所属组织架构都添加该pv
|
||
if pv and g.user and g.user.org:
|
||
roles = session.query(self.role_model).all() # 获取所有角色，自动在相应角色下面添加pv
|
||
if roles:
|
||
for role in roles:
|
||
if role.name in g.user.org:
|
||
# 为pvm-role表中添加记录
|
||
pv_role = session.execute(select([assoc_permissionview_role.c.id]).where(assoc_permissionview_role.c.permission_view_id==pv.id)
|
||
.where(assoc_permissionview_role.c.role_id==role.id)
|
||
.limit(1)
|
||
).fetchall()
|
||
if not pv_role:
|
||
session.execute(assoc_permissionview_role.insert().values(
|
||
permission_view_id=pv.id, role_id=role.id
|
||
)
|
||
)
|
||
except Exception as e:
|
||
logging.error(e)
|
||
|
||
|
||
|
||
@classmethod
|
||
def get_join_projects_id(self,session):
|
||
from myapp.models.model_team import Project_User
|
||
if g.user:
|
||
projects_id = session.query(Project_User.project_id).filter(Project_User.user_id == User.get_user_id()).all()
|
||
projects_id = [project_id[0] for project_id in projects_id]
|
||
return projects_id
|
||
else:
|
||
return []
|
||
|
||
|
||
@classmethod
|
||
def get_create_pipeline_ids(self,session):
|
||
from myapp.models.model_job import Pipeline
|
||
if g.user:
|
||
pipeline_ids = session.query(Pipeline.id).filter(Pipeline.created_by_fk == User.get_user_id()).all()
|
||
pipeline_ids = [pipeline_id[0] for pipeline_id in pipeline_ids]
|
||
return pipeline_ids
|
||
else:
|
||
return []
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|