def get(self, request, *args, **kwargs):
"""
获取企业下用户信息列表
"""
try:
enterprise_id = request.GET.get("enterprise_id", None)
page_num = int(request.GET.get("page_num", 1))
page_size = int(request.GET.get("page_size", 5))
user_name = request.GET.get("user_name", None)
if not enterprise_id:
enter = console_enterprise_service.get_enterprise_by_id(enterprise_id=self.user.enterprise_id)
enterprise_id = enter.enterprise_id
enter = console_enterprise_service.get_enterprise_by_id(enterprise_id=enterprise_id)
if user_name:
euser = user_services.get_user_by_user_name(enterprise_id, user_name)
list = []
if not euser:
result = general_message("0000", "success", "查询成功", list=list, total=0)
return Response(result)
result_map = dict()
result_map["user_id"] = euser.user_id
result_map["email"] = euser.email
result_map["nick_name"] = euser.nick_name
result_map["phone"] = euser.phone if euser.phone else "暂无"
result_map["create_time"] = time_to_str(euser.create_time, "%Y-%m-%d %H:%M:%S")
tenant_list = user_services.get_user_tenants(euser.user_id)
result_map["tenants"] = tenant_list
result_map["enterprise_alias"] = enter.enterprise_alias
list.append(result_map)
result = general_message("0000", "success", "查询成功", list=list, total=1)
return Response(result)
user_list = user_repo.get_user_by_enterprise_id(enterprise_id=enterprise_id)
for user1 in user_list:
if user1.nick_name == self.user.nick_name:
user_list.delete(user1)
user_paginator = JuncheePaginator(user_list, int(page_size))
users = user_paginator.page(int(page_num))
list = []
for user in users:
result_map = dict()
result_map["user_id"] = user.user_id
result_map["email"] = user.email
result_map["nick_name"] = user.nick_name
result_map["phone"] = user.phone if user.phone else "暂无"
result_map["create_time"] = time_to_str(user.create_time, "%Y-%m-%d %H:%M:%S")
tenant_list = user_services.get_user_tenants(user.user_id)
result_map["tenants"] = tenant_list
result_map["enterprise_alias"] = enter.enterprise_alias
list.append(result_map)
result = general_message("0000", "success", "查询成功", list=list, total=user_paginator.count)
except Exception as e:
logger.debug(e)
result = error_message()
return Response(result)
def get(self, req, eid):
ent = enterprise_services.get_enterprise_by_id(eid)
if ent is None:
return Response({"msg": "企业不存在"}, status=status.HTTP_404_NOT_FOUND)
serializer = EnterpriseInfoSerializer(data=ent.to_dict())
serializer.is_valid(raise_exception=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, req, eid):
data = {
"enterprise_id": eid,
"used_cpu": 0,
"used_memory": 0,
"used_disk": 0
}
if not req.user.is_administrator:
raise ServiceHandleException(status_code=401,
error_code=401,
msg="Permission denied")
ent = enterprise_services.get_enterprise_by_id(eid)
if ent is None:
return Response({"msg": "企业不存在"}, status=status.HTTP_404_NOT_FOUND)
regions = region_services.get_regions_by_enterprise_id(eid)
for region in regions:
try:
res, body = region_api.get_region_resources(
eid, region.region_name)
rst = body.get("bean")
if res.get("status") == 200 and rst:
data["used_cpu"] += rst.get("req_cpu", 0)
data["used_memory"] += rst.get("req_mem", 0)
data["used_disk"] += rst.get("req_disk", 0)
except ServiceHandleException:
continue
serializer = EnterpriseSourceSerializer(data=data)
serializer.is_valid(raise_exception=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def initial(self, request, *args, **kwargs):
request.user.is_administrator = False
if hasattr(request.user, "enterprise_id"):
self.enterprise = enterprise_services.get_enterprise_by_id(request.user.enterprise_id)
if not self.enterprise:
raise ErrEnterpriseNotFound
if self.enterprise.ID == 1:
request.user.is_administrator = True
self.user = request.user
self.is_team_owner = False
team_id = kwargs.get("team_id")
if team_id:
self.team = team_services.get_team_by_team_id_and_eid(team_id, self.enterprise.enterprise_id)
if not self.team:
self.team = team_services.get_enterprise_tenant_by_tenant_name(self.enterprise.enterprise_id, team_id)
if not self.team:
raise ServiceHandleException(msg_show="团队不存在", msg="no found team", status_code=404)
self.team_regions = region_services.get_team_usable_regions(self.team.tenant_name, self.enterprise.enterprise_id)
if self.user.user_id == self.team.creater:
self.is_team_owner = True
self.enterprise = TenantEnterprise.objects.filter(enterprise_id=self.team.enterprise_id).first()
self.is_enterprise_admin = False
enterprise_user_perms = EnterpriseUserPerm.objects.filter(
enterprise_id=self.team.enterprise_id, user_id=self.user.user_id).first()
if enterprise_user_perms:
self.is_enterprise_admin = True
self.get_perms()
self.check_perms(request, *args, **kwargs)
def initial(self, request, *args, **kwargs):
super(BaseOpenAPIView, self).initial(request, *args, **kwargs)
request.user.is_administrator = False
if hasattr(request.user, "enterprise_id"):
self.enterprise = enterprise_services.get_enterprise_by_id(
request.user.enterprise_id)
if self.enterprise.ID == 1:
request.user.is_administrator = True
def post(self, request, tenant_name, *args, **kwargs):
"""
为团队添加用户
---
parameters:
- name: tenant_name
description: 团队名
required: true
type: string
paramType: path
- name: user_name
description: 用户名
required: true
type: string
paramType: form
- name: identity
description: 权限
required: true
type: string
paramType: form
"""
try:
user_name = request.data.get("user_name", None)
if not user_name:
return Response(
generate_result("1003", "username is null", "用户名不能为空"))
identity = request.data.get("identity", "viewer")
if not identity:
return Response(
generate_result("1003", "identity is null", "用户权限不能为空"))
user = user_service.get_user_by_username(user_name)
tenant = tenant_service.get_tenant(tenant_name)
if not tenant:
result = generate_result("1001", "tenant not exist",
"租户{}不存在".format(tenant_name))
return Response(result)
enterprise = enterprise_services.get_enterprise_by_id(
tenant.enterprise_id)
tenant_service.add_user_to_tenant(tenant, user, identity,
enterprise)
result = generate_result("0000", "success", "用户添加成功")
except PermTenantsExistError as e:
result = generate_result("1009", "permtenant exist", e.message)
except UserNotExistError as e:
result = generate_result("1008", "user not exist", e.message)
except Tenants.DoesNotExist as e:
logger.exception(e)
result = generate_result("1001", "tenant not exist",
"租户{}不存在".format(tenant_name))
except Exception as e:
logger.exception(e)
result = generate_result("9999", "system error", "系统异常")
return Response(result)
def put(self, req, eid):
serializer = UpdAppStoreInfoReqSerializer(data=req.data)
serializer.is_valid(raise_exception=True)
if enterprise_services.get_enterprise_by_id(eid) is None:
raise exceptions.NotFound({"msg": "企业'{}'不存在".format(eid)})
try:
res = enterprise_services.update_appstore_info(eid, req.data)
except TenantEnterpriseToken:
raise exceptions.NotFound({"msg": "应用市场信息不存在 {}".format(eid)})
serializer = AppStoreInfoSerializer(res)
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, req, *args, **kwargs):
key = req.GET.get("key", None)
ent = enterprise_services.get_enterprise_by_id(
self.enterprise.enterprise_id)
if ent is None:
return Response({"msg": "企业不存在"}, status=status.HTTP_404_NOT_FOUND)
ent_config = EnterpriseConfigService(
self.enterprise.enterprise_id).initialization_or_get_config
if key is None:
serializer = EnterpriseConfigSeralizer(data=ent_config)
elif key in list(ent_config.keys()):
serializer = EnterpriseConfigSeralizer(data={key: ent_config[key]})
else:
raise ServiceHandleException(
status_code=404,
msg="no found config key {}".format(key),
msg_show="企业没有 {} 配置".format(key))
serializer.is_valid(raise_exception=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
"""
获取企业可加入的团队列表
"""
try:
enterprise_id = request.GET.get("enterprise_id", None)
page_num = int(request.GET.get("page_num", 1))
page_size = int(request.GET.get("page_size", 5))
if not enterprise_id:
enter = enterprise_services.get_enterprise_by_id(
enterprise_id=self.user.enterprise_id)
enterprise_id = enter.enterprise_id
total = 0
t_list = []
owner_name = None
team_list = team_services.get_enterprise_teams(
enterprise_id=enterprise_id)
team_paginator = JuncheePaginator(team_list, int(page_size))
total = team_paginator.count
page_team = team_paginator.page(page_num)
t_list = [{
"enterprise_id":
team_info.enterprise_id,
"create_time":
team_info.create_time,
"team_name":
team_info.tenant_name,
"team_alias":
team_info.tenant_alias,
"owner":
user_repo.get_user_nickname_by_id(user_id=team_info.creater)
} for team_info in page_team]
result = general_message(200,
"success",
"查询成功",
list=t_list,
total=total)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def initial(self, request, *args, **kwargs):
super(BaseOpenAPIView, self).initial(request, *args, **kwargs)
request.user.is_ = False
if hasattr(request.user, "enterprise_id"):
self.enterprise = enterprise_services.get_enterprise_by_id(request.user.enterprise_id)
if not self.enterprise:
raise ErrEnterpriseNotFound
self.region_name = kwargs.get("region_name")
if not self.region_name:
self.region_name = kwargs.get("region_id")
if self.region_name:
self.region = region_services.get_enterprise_region_by_region_name(
enterprise_id=self.enterprise.enterprise_id, region_name=self.region_name)
if not self.region:
self.region = region_repo.get_region_by_id(self.enterprise.enterprise_id, self.region_name)
# Temporary logic
if self.enterprise.ID == 1:
request.user.is_administrator = True
self.user = request.user
self.get_perms()
self.check_perms(request, *args, **kwargs)
def _update_entalias(self, eid, alias):
ent = enterprise_services.get_enterprise_by_id(eid)
if ent is None:
raise TenantEnterprise.DoesNotExist()
ent.enterprise_alias = alias
ent.save()
