def get(self, request, team_name, *args, **kwargs):
"""
企业账户信息查询接口
---
parameters:
- name: team_name
description: 当前团队名字
required: true
type: string
paramType: path
"""
try:
team = team_services.get_tenant_by_tenant_name(
tenant_name=team_name, exception=True)
res, data = open_api.get_enterprise_account_info(
tenant_id=team.tenant_id, enterprise_id=team.enterprise_id)
if res["status"] == 200:
code = 200
result = general_message(
code=code,
msg="corporate account information is successful.",
msg_show="企业账户信息获取成功",
bean=data)
else:
code = 400
result = general_message(
code=code,
msg="corporate account information failed",
msg_show="企业账户信息获取失败")
except Exception as e:
code = 500
logger.exception(e)
result = error_message(e.message)
return Response(result, status=code)
def get(self, request, team_name, *args, **kwargs):
"""
邀请注册，弹框的详情
---
parameters:
- name: team_name
description: 邀请进入的团队id
required: true
type: string
paramType: path
"""
try:
team = team_services.get_tenant_by_tenant_name(
tenant_name=team_name)
team_id = str(team.ID)
data = dict()
# url = "http://" + request.get_host() + '/console/users/register?tag=' + team_id
data["register_type"] = "invitation"
data["value"] = team_id
result = general_message(200, "success", "成功获得邀请码", bean=data)
return Response(result, status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def post(self, request, team_name, *args, **kwargs):
"""
为团队开通数据中心
---
parameters:
- name: team_name
description: 当前团队名字
required: true
type: string
paramType: path
- name: region_name
description: 要开通的数据中心名称
required: true
type: string
paramType: body
"""
region_name = request.data.get("region_name", None)
if not region_name:
return Response(general_message(400, "params error", "参数异常"),
status=400)
team = team_services.get_tenant_by_tenant_name(team_name)
if not team:
return Response(general_message(404, "team is not found",
"团队{0}不存在".format(team_name)),
status=403)
region_services.create_tenant_on_region(self.enterprise.enterprise_id,
team_name, region_name)
result = general_message(200, "success",
"数据中心{0}开通成功".format(region_name))
return Response(result, result["code"])
def post(self, request, *args, **kwargs):
"""
应用迁移
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: region
description: 需要备份的数据中心
required: true
type: string
paramType: form
- name: team
description: 需要迁移到的团队
required: true
type: string
paramType: form
- name: backup_id
description: 备份ID
required: true
type: string
paramType: form
"""
try:
migrate_region = request.data.get("region", None)
team = request.data.get("team", None)
backup_id = request.data.get("backup_id", None)
if not team:
return Response(general_message(400, "team is null",
"请指明要迁移的团队"),
status=400)
migrate_team = team_services.get_tenant_by_tenant_name(team)
if not migrate_team:
return Response(general_message(404, "team is not found",
"需要迁移的团队{0}不存在".format(team)),
status=404)
regions = region_services.get_team_usable_regions(migrate_team)
if migrate_region not in [r.region_name for r in regions]:
return Response(general_message(
412, "region is not usable",
"无法迁移至数据中心{0},请确保该数据中心可用且您已开通该数据中心权限".format(
migrate_region)),
status=412)
code, msg = migrate_service.start_migrate(
self.user, self.tenant.tenant_name, self.response_region,
migrate_team, migrate_region, backup_id)
if code != 200:
return Response(general_message(code, "migrate failed", msg),
status=code)
result = general_message(200, "success", "操作成功，开始迁移应用")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, team_name, *args, **kwargs):
"""
为团队开通数据中心
---
parameters:
- name: team_name
description: 当前团队名字
required: true
type: string
paramType: path
- name: region_name
description: 要开通的数据中心名称
required: true
type: string
paramType: body
"""
try:
region_name = request.data.get("region_name", None)
if not region_name:
return Response(general_message(400, "params error", "参数异常"), status=400)
team = team_services.get_tenant_by_tenant_name(team_name)
if not team:
return Response(general_message(404, "team is not found", "团队{0}不存在".format(team_name)), status=403)
is_admin = user_services.is_user_admin_in_current_enterprise(self.user, team.enterprise_id)
if not is_admin:
return Response(
general_message(403, "current user is not admin in current enterprise", "用户不为当前企业管理员"), status=403)
code, msg, tenant_region = region_services.create_tenant_on_region(team_name, region_name)
if code != 200:
return Response(general_message(code, "open region error", msg), status=code)
result = general_message(code, "success", "数据中心{0}开通成功".format(region_name))
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, result["code"])
def initial(self, request, *args, **kwargs):
super(ToplogicalBaseView, self).initial(request, *args, **kwargs)
self.tenant_name = kwargs.get("tenantName", None)
service_alias = kwargs.get("serviceAlias", None)
self.user = request.user
if kwargs.get("team_name", None):
self.tenant_name = kwargs.get("team_name", None)
self.team_name = self.tenant_name
if not self.response_region:
self.response_region = request.GET.get('region', None)
if not self.response_region:
raise ImportError("region_name not found !")
if not self.tenant_name:
raise ImportError("team_name not found !")
if self.tenant_name:
tenant = team_services.get_tenant_by_tenant_name(self.tenant_name)
if tenant:
self.tenant = tenant
self.team = tenant
else:
raise NotFound("tenant {0} not found".format(self.tenant_name))
if service_alias:
self.service = service_repo.get_service_by_tenant_and_alias(
self.tenant.tenant_id, service_alias)
self.initial_header_info(request)
def __check_domain_name(self, team_name, domain_name, domain_type, certificate_id):
if not domain_name:
return 400, u"域名不能为空"
zhPattern = re.compile(u'[\u4e00-\u9fa5]+')
match = zhPattern.search(domain_name.decode('utf-8'))
if match:
return 400, u"域名不能包含中文"
# a租户绑定了域名manage.com,b租户就不可以在绑定该域名，只有a租户下可以绑定
s_domain = domain_repo.get_domain_by_domain_name(domain_name)
if s_domain:
team = team_services.get_tenant_by_tenant_name(team_name)
if team:
if s_domain.tenant_id != team.tenant_id:
return 400, u"该域名已被其他团队使用"
# re_exp = "^(?=^.{3,255}$)[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+$"
# if not re.match(re_exp, domain_name):
# return 400, u"域名不规范（示例：www.example.com 域名不应包含协议头）"
if len(domain_name) > 256:
return 400, u"域名过长"
if certificate_id:
certificate_info = domain_repo.get_certificate_by_pk(int(certificate_id))
cert = base64.b64decode(certificate_info.certificate)
data = analyze_cert(cert)
certificat_domain_name = data["issued_to"]
if certificat_domain_name.startswith('*'):
domain_suffix = certificat_domain_name[2:]
else:
domain_suffix = certificat_domain_name
logger.debug('---------domain_suffix-------->{0}'.format(domain_suffix))
domain_str = domain_name.encode('utf-8')
if not domain_str.endswith(domain_suffix):
return 400, u"域名和证书不匹配"
return 200, u"success"
def get(self, request, tenant_name, *args, **kwargs):
"""
获取团队可用的数据中心
---
parameters:
- name: tenant_name
description: 团队名
required: true
type: string
paramType: path
"""
region_name = None
try:
team = console_team_service.get_tenant_by_tenant_name(tenant_name)
if not team:
return Response(
generate_result("0404", "team not found",
"团队{0}不存在".format(tenant_name)))
region_list = console_region_service.get_region_list_by_team_name(
request, tenant_name)
if region_list:
region_name = region_list[0]["team_region_name"]
else:
regions = region_service.get_all_regions()
if regions:
region_name = regions[0].region_name
result = generate_result("0000",
"success",
"查询成功",
bean={"region_name": region_name})
except Exception as e:
logger.exception(e)
result = generate_result("9999", "system error", "系统异常")
return Response(result)
def post(self, request, region_name):
"""资源费用计算"""
team_name = request.data.get('team_name')
team = team_services.get_tenant_by_tenant_name(
tenant_name=team_name, exception=True
)
if not team:
return Response(
general_message(404, "team not found", "指定团队不存在"), status=404
)
try:
memory = int(request.data.get('memory', 0))
disk = int(request.data.get('disk', 0))
rent_time = request.data.get('rent_time')
ret, msg, status = market_api.get_region_res_price(
region_name, team.tenant_id, team.enterprise_id, memory, disk, rent_time
)
return Response(status=status, data=general_message(status, msg, msg, ret))
except Exception as e:
data = general_message(500, "cal fee error", "无法计算费用")
return Response(status=500, data=data)
def post(self, request, region_name):
"""资源购买"""
team_name = request.data.get('team_name')
team = team_services.get_tenant_by_tenant_name(tenant_name=team_name,
exception=True)
if not team:
return Response(general_message(404, "team not found", "指定团队不存在"),
status=404)
try:
memory = int(request.data.get('memory', 0))
disk = int(request.data.get('disk', 0))
rent_time = request.data.get('rent_time')
ret, msg, status = market_api.buy_region_res(
region_name, team.tenant_id, team.enterprise_id, memory, disk,
rent_time)
if status == 10408:
return Response(status=412,
data=general_message(status, msg, msg, ret))
return Response(status=status,
data=general_message(status, msg, msg, ret))
except Exception as e:
logger.exception(e)
data = general_message(500, "buy res error", "资源购买失败")
return Response(status=500, data=data)
def post(self, request, *args, **kwargs):
"""
应用迁移
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: region
description: 需要备份的数据中心
required: true
type: string
paramType: form
- name: team
description: 需要迁移到的团队
required: true
type: string
paramType: form
- name: backup_id
description: 备份ID
required: true
type: string
paramType: form
- name: migrate_type
description: 操作类型
required: true
type: string
paramType: form
"""
migrate_region = request.data.get("region", None)
team = request.data.get("team", None)
backup_id = request.data.get("backup_id", None)
migrate_type = request.data.get("migrate_type", "migrate")
event_id = request.data.get("event_id", None)
restore_id = request.data.get("restore_id", None)
if not team:
return Response(general_message(400, "team is null", "请指明要迁移的团队"), status=400)
migrate_team = team_services.get_tenant_by_tenant_name(team)
if not migrate_team:
return Response(general_message(404, "team is not found", "需要迁移的团队{0}不存在".format(team)), status=404)
regions = region_services.get_team_usable_regions(migrate_team)
if migrate_region not in [r.region_name for r in regions]:
msg_cn = "无法迁移至数据中心{0},请确保该数据中心可用且团队{1}已开通该数据中心权限".format(
migrate_region, migrate_team.tenant_name)
return Response(general_message(412, "region is not usable", msg_cn), status=412)
migrate_record = migrate_service.start_migrate(
self.user, self.tenant, self.region_name, migrate_team, migrate_region,
backup_id, migrate_type, event_id, restore_id)
result = general_message(200, "success", "操作成功，开始迁移应用", bean=migrate_record.to_dict())
return Response(result, status=result["code"])
def get(self, request, team_name, *args, **kwargs):
"""
获取团队详情
---
parameters:
- name: team_name
description: team name
required: true
type: string
paramType: path
"""
try:
tenant = team_services.get_tenant_by_tenant_name(team_name)
if not tenant:
return Response(general_message(404, "team not exist", "团队{0}不存在".format(team_name)), status=404)
user_team_perm = team_services.get_user_perms_in_permtenant(self.user.user_id, team_name)
tenant_info = dict()
team_region_list = region_services.get_region_list_by_team_name(request=request,
team_name=team_name)
p = PermActions()
tenant_info["team_id"] = tenant.ID
tenant_info["team_name"] = tenant.tenant_name
tenant_info["team_alias"] = tenant.tenant_alias
tenant_info["limit_memory"] = tenant.limit_memory
tenant_info["pay_level"] = tenant.pay_level
tenant_info["region"] = team_region_list
tenant_info["creater"] = tenant.creater
tenant_info["create_time"] = tenant.create_time
if not user_team_perm:
if not self.user.is_sys_admin and team_name != "grdemo":
return Response(general_message(403, "you right to see this team", "您无权查看此团队"), 403)
else:
perms_list = team_services.get_user_perm_identitys_in_permtenant(user_id=self.user.user_id,
tenant_name=tenant.tenant_name)
role_name_list = team_services.get_user_perm_role_in_permtenant(user_id=self.user.user_id,
tenant_name=tenant.tenant_name)
role_perms_tuple = team_services.get_user_perm_in_tenant(user_id=self.user.user_id,
tenant_name=tenant.tenant_name)
tenant_actions = ()
tenant_info["identity"] = perms_list + role_name_list
if perms_list:
final_identity = get_highest_identity(perms_list)
perms = p.keys('tenant_{0}_actions'.format(final_identity))
tenant_actions += perms
tenant_actions += role_perms_tuple
tenant_info["tenant_actions"] = tuple(set(tenant_actions))
return Response(general_message(200, "success", "查询成功", bean=tenant_info), status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, enterprise_id, *args, **kwargs):
tenant_name = request.data.get("tenant_name", None)
user_name = request.data.get("user_name", None)
email = request.data.get("email", None)
password = request.data.get("password", None)
re_password = request.data.get("re_password", None)
role_ids = request.data.get("role_ids", None)
phone = request.data.get("phone", None)
real_name = request.data.get("real_name", None)
tenant = team_services.get_tenant_by_tenant_name(tenant_name)
if len(password) < 8:
result = general_message(400, "len error", "密码长度最少为8位")
return Response(result)
# check user info
is_pass, msg = user_services.check_params(user_name, email, password,
re_password,
request.user.enterprise_id)
if not is_pass:
result = general_message(403, "user information is not passed",
msg)
return Response(result)
client_ip = user_services.get_client_ip(request)
enterprise = enterprise_services.get_enterprise_by_enterprise_id(
enterprise_id)
# create user
oauth_instance, _ = user_services.check_user_is_enterprise_center_user(
request.user.user_id)
if oauth_instance:
user = user_services.create_enterprise_center_user_set_password(
user_name, email, password, "admin add", enterprise, client_ip,
phone, real_name, oauth_instance)
else:
user = user_services.create_user_set_password(
user_name, email, password, "admin add", enterprise, client_ip,
phone, real_name)
result = general_message(200, "success", "添加用户成功")
if tenant:
create_perm_param = {
"user_id": user.user_id,
"tenant_id": tenant.ID,
"identity": "",
"enterprise_id": enterprise.ID,
}
team_repo.create_team_perms(**create_perm_param)
if role_ids:
user_kind_role_service.update_user_roles(
kind="team",
kind_id=tenant.tenant_id,
user=user,
role_ids=role_ids)
user.is_active = True
user.save()
result = general_message(200, "success", "添加用户成功")
return Response(result)
def get(self, request, *args, **kwargs):
"""
获取用户操作信息
---
parameters:
- name: page_num
description: 页码
required: false
type: string
paramType: query
- name: page_size
description: 每页数量(默认20)
required: false
type: string
paramType: query
- name: team_name
description: 团队名称
required: false
type: string
paramType: query
- name: create_time
description: 创建时间
required: false
type: string
paramType: query
- name: status
description: 事件状态（success,failure,timeout）默认 failure
required: false
type: string
paramType: query
"""
try:
page = request.GET.get("page_num", 1)
page_size = request.GET.get("page_size", 20)
team_name = request.GET.get("team_name", None)
create_time = request.GET.get("create_time", None)
status = request.GET.get("status", None)
team = None
if team_name:
team = console_team_service.get_tenant_by_tenant_name(team_name)
if not team:
return Response(generate_result("0404", "team not found", "团队{0}不存在".format(team_name)))
show_events, total = service_event_dynamic.get_services_events(int(page), int(page_size), create_time, status, team)
result_list = []
for e in show_events:
bean = e.to_dict()
bean.update({"service_cname": e.service_cname, "service_alias": e.service_alias,
"service_region": e.service_region, "team_name": e.team_name})
result_list.append(bean)
result = generate_result("0000", "query success", "查询成功", list=result_list,total=total)
except Exception as e:
logger.exception(e)
result = generate_error_result()
return Response(result)
def get(self, request, team_name):
"""
企业购买明细
---
parameters:
- name: start
required: true
type: string
location: 'query'
description: 开始时间
- name: end
required: true
type: string
location: 'query'
description: 结束时间
- name: page
required: true
type: string
location: 'query'
description: 第几页
- name: page_size
required: true
type: string
location: 'query'
description: 每页条数
"""
try:
start = request.GET.get('start')
end = request.GET.get('end')
page = request.GET.get('page', 1)
page_size = request.GET.get('page_size', 10)
team = team_services.get_tenant_by_tenant_name(team_name)
if not team:
return Response(general_message(404, "team not exist",
"指定的团队不存在"),
status=404)
total = 0
result_list = []
try:
res, dict_body = market_api.get_enterprise_purchase_detail(
team.tenant_id, team.enterprise_id, start, end, page,
page_size)
result_list = dict_body["data"]["list"]
total = dict_body["data"]["total"]
except Exception as ex:
logger.exception(ex)
result = general_message(200,
"success",
"查询成功",
list=result_list,
total=total)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def get(self, request, *args, **kwargs):
"""
团队管理员可以获取公有云的数据中心列表
---
parameters:
- name: enterprise_id
description: 企业id
required: true
type: string
paramType: path
- name: team_name
description: 当前团队名字
required: true
type: string
paramType: query
"""
try:
team_name = request.GET.get("team_name", None)
if not team_name:
return Response(general_message(400, "params error", "参数错误"),
status=400)
perm_list = team_services.get_user_perm_identitys_in_permtenant(
user_id=request.user.user_id, tenant_name=team_name)
role_name_list = team_services.get_user_perm_role_in_permtenant(
user_id=request.user.user_id, tenant_name=team_name)
perm = "owner" not in perm_list and "admin" not in perm_list
if perm and "owner" not in role_name_list and "admin" not in role_name_list:
code = 400
result = general_message(code, "no identity",
"您不是owner或admin，没有权限做此操作")
return Response(result, status=code)
team = team_services.get_tenant_by_tenant_name(
tenant_name=team_name, exception=True)
res, data = market_api.get_public_regions_list(
tenant_id=team.tenant_id, enterprise_id=team.enterprise_id)
if res["status"] == 200:
code = 200
result = general_message(
code,
"query the data center is successful.",
"公有云数据中心获取成功",
list=data)
else:
code = 400
result = general_message(code,
msg="query the data center failed",
msg_show="公有云数据中心获取失败")
except Exception as e:
code = 500
logger.exception(e)
result = error_message(e.message)
return Response(result, status=code)
def get(self, request, team_name):
"""
查询企业的充值记录
---
parameters:
- name: start
description: 开始时间
required: true
type: string
paramType: query
- name: end
description: 结束时间
required: true
type: string
paramType: query
- name: page
description: 页数(默认第一页)
required: false
type: string
paramType: query
- name: page_size
description: 每页展示个数(默认10个)
required: false
type: string
paramType: query
"""
try:
start_time = request.GET.get("start")
end_time = request.GET.get("end")
page = request.GET.get("page", 1)
page_size = request.GET.get("page_size", 10)
team = team_services.get_tenant_by_tenant_name(team_name)
if not team:
return Response(general_message(404, "team not found",
"团队{0}不存在".format(team_name)),
status=404)
enterprise = enterprise_services.get_enterprise_by_enterprise_id(
team.enterprise_id)
res, data = market_api.get_enterprise_recharge_records(
team.tenant_id, enterprise.enterprise_id, start_time, end_time,
page, page_size)
result = general_message(200,
"get recharge record success",
"查询成功",
list=data["data"]["list"],
total=data["data"]["total"])
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def get(self, request, *args, **kwargs):
"""
一个组的备份导出
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: backup_id
description: 备份id
required: true
type: string
paramType: query
"""
try:
group_id = int(kwargs.get("group_id", None))
if not group_id:
return Response(general_message(400, "group id is null", "请选择需要导出备份的组"), status=400)
team_name = kwargs.get("tenantName", None)
if not team_name:
return Response(general_message(400, "group id is null", "请选择需要导出备份的组"), status=400)
team = team_services.get_tenant_by_tenant_name(team_name)
if not team:
return Response(general_message(404, "team not found", "团队{0}不存在".format(team_name)), status=404)
group = group_repo.get_group_by_id(group_id)
if not group:
return Response(general_message(404, "group not found", "组{0}不存在".format(group_id)), status=404)
backup_id = request.GET.get("backup_id", None)
if not backup_id:
return Response(general_message(400, "backup id is null", "请指明当前组的具体备份项"), status=400)
code, msg, data_str = groupapp_backup_service.export_group_backup(team, backup_id)
if code != 200:
return Response(general_message(code, "export backup failed", msg), status=code)
file_name = group.group_name + ".bak"
output = StringIO.StringIO()
output.write(data_str)
res = StreamingHttpResponse(output.getvalue())
res['Content-Type'] = 'application/octet-stream'
res['Content-Disposition'] = 'attachment;filename="{0}"'.format(file_name)
return res
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def __process_invite_tenant(self, user, data):
email, tenant_name, identity = data[1], data[2], data[3]
tenant = team_services.get_tenant_by_tenant_name(tenant_name)
tenant_perm = perm_services.get_user_tenant_perm(tenant.ID, user.user_id)
if not tenant_perm:
invite_enter = enterprise_services.get_enterprise_by_enterprise_id(tenant.enterprise_id)
perm_info = {
"user_id": user.user_id,
"tenant_id": tenant.ID,
"identity": identity,
"enterprise_id": invite_enter.pk
}
perm_services.add_user_tenant_perm(perm_info)
def get(self, request, *args, **kwargs):
"""
获取服务的event的详细日志
---
parameters:
- name: team_name
description: 团队名称
required: true
type: string
paramType: query
- name: service_alias
description: 服务别名
required: true
type: string
paramType: query
- name: level
description: 日志等级
required: false
type: string
paramType: query
- name: event_id
description: 事件id
required: true
type: string
paramType: query
"""
try:
team_name = request.GET.get("team_name", None)
service_alias = request.GET.get("service_alias", None)
level = request.GET.get("level", LogConstants.INFO)
event_id = request.GET.get("event_id", None)
if not team_name:
return Response(generate_result("0400", "team name is null", "团队名称不能为空"))
if not service_alias:
return Response(generate_result("0400", "serice alias is null", "服务别名不能为空"))
if not event_id:
return Response(generate_result("0400", "event id is null", "请指明事件id"))
team = console_team_service.get_tenant_by_tenant_name(team_name)
if not team:
return Response(generate_result("0404", "team is not found", "团队{0}不存在".format(team_name)))
service = service_repo.get_service_by_service_alias(service_alias)
if not service:
return Response(generate_result("0404", "team is not found", "应用{0}不存在".format(service_alias)))
log_list = event_service.get_service_event_log(team, service, level, event_id)
result = generate_result("0000", "success", "查询成功", list=log_list)
except Exception as e:
logger.exception(e)
result = generate_error_result()
return Response(result)
def get(self, request, *args, **kwargs):
"""
公有云数据中心资源详情
---
parameters:
- name: enterprise_id
description: 企业id
required: true
type: string
paramType: path
- name: team_name
description: 当前团队名字
required: true
type: string
paramType: query
- name: region
description: 数据中心名称
required: true
type: string
paramType: query
"""
try:
team_name = request.GET.get("team_name", None)
region = request.GET.get("region", None)
if not team_name:
return Response(general_message(400, "team name is null",
"参数错误"),
status=400)
if not region:
return Response(general_message(400, "region name is null",
"请指明数据中心"),
status=400)
team = team_services.get_tenant_by_tenant_name(
tenant_name=team_name, exception=True)
if not team:
return Response(general_message(404, "team not found",
"指定团队不存在"),
status=404)
res, data = market_api.get_enterprise_regions_resource(
tenant_id=team.tenant_id,
region=region,
enterprise_id=team.enterprise_id)
result = general_message(200, "success", "查询成功", bean=data)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def delete(self, request, team_name, *args, **kwargs):
"""
删除当前团队
---
parameters:
- name: team_name
description: 要删除的团队
required: true
type: string
paramType: path
"""
code = 200
identity_list = team_services.get_user_perm_identitys_in_permtenant(
user_id=request.user.user_id, tenant_name=team_name)
perm_tuple = team_services.get_user_perm_in_tenant(
user_id=request.user.user_id, tenant_name=team_name)
team = team_services.get_tenant_by_tenant_name(team_name)
if not user_services.is_user_admin_in_current_enterprise(
request.user, team.enterprise_id):
if "owner" not in identity_list and "drop_tenant" not in perm_tuple:
code = 400
result = general_message(code, "no identity",
"您不是最高管理员，不能删除团队")
return Response(result, status=code)
try:
service_count = team_services.get_team_service_count_by_team_name(
team_name=team_name)
if service_count >= 1:
result = general_message(400, "failed", "当前团队内有应用,不可以删除")
return Response(result, status=400)
status = team_services.delete_tenant(tenant_name=team_name)
if not status:
result = general_message(code, "delete a tenant successfully",
"删除团队成功")
else:
code = 400
result = general_message(code, "delete a tenant failed",
"删除团队失败")
except Tenants.DoesNotExist as e:
code = 400
logger.exception(e)
result = generate_result(code, "tenant not exist",
"{}团队不存在".format(team_name))
except Exception as e:
code = 500
result = general_message(code, "sys exception", "系统异常")
logger.exception(e)
return Response(result, status=code)
def get(self, request, team_name, user_name, *args, **kwargs):
"""
用户详情
---
parameters:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: user_name
description: 用户名
required: true
type: string
paramType: path
"""
try:
# u, perms = user_services.get_user_detail(tenant_name=team_name, nick_name=user_name)
team = team_services.get_tenant_by_tenant_name(team_name)
is_user_enter_amdin = user_services.is_user_admin_in_current_enterprise(
self.user, team.enterprise_id)
perms = team_services.get_user_perm_identitys_in_permtenant(
self.user.user_id, team_name)
role_list = team_services.get_user_perm_role_in_permtenant(
user_id=self.user.user_id, tenant_name=team_name)
# teams = [{"team_identity": perm.identity} for perm in perms]
data = dict()
data["nick_name"] = self.user.nick_name
data["email"] = self.user.email
# data["teams_identity"] = teams[0]["team_identity"]
data["teams_identity"] = perms + role_list
data["is_user_enter_amdin"] = is_user_enter_amdin
code = 200
result = general_message(code,
"user details query success.",
"用户详情获取成功",
bean=data)
return Response(result, status=code)
except UserNotExistError as e:
logger.exception(e)
code = 400
result = general_message(code,
"this user does not exist on this team.",
"该用户不存在这个团队")
return Response(result, status=code)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def get(self, request, team_name, *args, **kwargs):
"""
获取组件访问信息
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: service_list
description: 组件别名列表
required: true
type: string
paramType: path
"""
try:
serviceAlias = request.GET.get('service_alias')
if not serviceAlias:
result = general_message(200,
"not service",
"当前组内无组件",
bean={"is_null": True})
return Response(result)
team = team_services.get_tenant_by_tenant_name(team_name)
service_access_list = list()
if not team:
result = general_message(400, "not tenant", "团队不存在")
return Response(result)
service_list = serviceAlias.split('-')
for service_alias in service_list:
bean = dict()
service = service_repo.get_service_by_service_alias(
service_alias)
access_type, data = port_service.get_access_info(team, service)
bean["access_type"] = access_type
bean["access_info"] = data
service_access_list.append(bean)
result = general_message(200,
"success",
"操作成功",
list=service_access_list)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, *args, **kwargs):
serializer = AppPostInfoSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
data = serializer.data
logger.info(data["team_alias"])
tenant = team_services.get_tenant_by_tenant_name(data["team_alias"])
if not tenant:
raise serializers.ValidationError("指定租户不存在")
if not region_services.verify_team_region(
team_name=data["team_alias"], region_name=data["region_name"]):
raise serializers.ValidationError("指定数据中心租户未开通")
code, msg, group_info = group_service.add_group(
tenant, data["region_name"], data["app_name"])
if not group_info:
return Response(FailSerializer({"msg": msg}).data, status=code)
re = AppBaseInfoSerializer(group_info)
return Response(re.data, status=status.HTTP_201_CREATED)
def get(self, request, team_name, *args, **kwargs):
"""
团队管理员可以获取公有云的数据中心列表
---
parameters:
- name: team_name
description: 当前团队名字
required: true
type: string
paramType: path
"""
try:
perm_list = team_services.get_user_perm_identitys_in_permtenant(
user_id=request.user.user_id, tenant_name=team_name)
no_auth = ("owner" not in perm_list) and ("admin" not in perm_list)
if no_auth:
code = 400
result = general_message(code, "no identity",
"您不是管理员或拥有者，没有权限做此操作")
return Response(result, status=code)
else:
team = team_services.get_tenant_by_tenant_name(
tenant_name=team_name, exception=True)
res, data = open_api.get_public_regions_list(
tenant_id=team.tenant_id, enterprise_id=team.enterprise_id)
if res["status"] == 200:
code = 200
result = generate_result(
code,
"query the data center is successful.",
"公有云数据中心获取成功",
list=data)
else:
code = 400
result = general_message(
code,
msg="query the data center failed",
msg_show="公有云数据中心获取失败")
except Exception as e:
code = 500
logger.exception(e)
result = error_message(e.message)
return Response(result, status=code)
def get(self, request, team_name, *args, **kwargs):
"""
获取团队未开通的数据中心
---
parameters:
- name: team_name
description: 当前团队名字
required: true
type: string
paramType: path
"""
code = 200
team = team_services.get_tenant_by_tenant_name(team_name)
if not team:
result = general_message(404, "team no found", "团队不存在")
return Response(result, status=code)
unopen_regions = region_services.get_team_unopen_region(team_name, team.enterprise_id)
result = general_message(code, "query the data center is successful.", "数据中心获取成功", list=unopen_regions)
return Response(result, status=code)
def get(self, request, team_name, user_name, *args, **kwargs):
"""
用户详情
---
parameters:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: user_name
description: 用户名
required: true
type: string
paramType: path
"""
is_team_owner = False
try:
team = team_services.get_tenant_by_tenant_name(team_name)
data = dict()
data["nick_name"] = self.user.nick_name
data["email"] = self.user.email
role_list = user_kind_role_service.get_user_roles(
kind="team", kind_id=team.tenant_id, user=self.user)
data["teams_identity"] = role_list["roles"]
data["is_enterprise_admin"] = self.is_enterprise_admin
if team.creater == self.user.user_id:
is_team_owner = True
data["is_team_owner"] = is_team_owner
code = 200
result = general_message(code,
"user details query success.",
"用户详情获取成功",
bean=data)
return Response(result, status=code)
except UserNotExistError as e:
logger.exception(e)
code = 400
result = general_message(code,
"this user does not exist on this team.",
"该用户不存在这个团队")
return Response(result, status=code)
def get(self, request, *args, **kwargs):
"""
企业账户信息查询接口
---
parameters:
- name: enterprise_id
description: 企业ID
required: true
type: string
paramType: path
- name: team_name
description: 团队名称
required: true
type: string
paramType: query
"""
try:
team_name = request.GET.get("team_name", None)
if not team_name:
return Response(general_message(400, "team name is null",
"参数错误"),
status=400)
team = team_services.get_tenant_by_tenant_name(
tenant_name=team_name, exception=True)
try:
res, data = market_api.get_enterprise_account_info(
tenant_id=team.tenant_id, enterprise_id=team.enterprise_id)
result = general_message(200, "success", "查询成功", bean=data)
except Exception as e:
logger.exception(e)
result = general_message(
400, "corporate account information failed", "企业账户信息获取失败")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, team_name, *args, **kwargs):
"""
团队中添加新用户
---
parameters:
- name: team_name
description: 团队名称
required: true
type: string
paramType: path
- name: user_ids
description: 添加成员id 格式 {'user_ids':'1,2'}
required: true
type: string
paramType: body
- name: identitys
description: 选择权限(当前用户是管理员'admin'或者创建者'owner'就展示权限选择列表，不是管理员就没有这个选项, 默认被邀请用户权限是'access') 格式{"identitys": "viewer,access"}
required: true
type: string
paramType: body
"""
perm_list = team_services.get_user_perm_identitys_in_permtenant(
user_id=request.user.user_id,
tenant_name=team_name
)
# 根据用户在一个团队的角色来获取这个角色对应的所有权限操作
role_perm_tuple = team_services.get_user_perm_in_tenant(user_id=request.user.user_id, tenant_name=team_name)
if perm_list:
no_auth = ("owner" not in perm_list) and ("admin" not in perm_list)
else:
no_auth = "manage_team_member_permissions" not in role_perm_tuple
if no_auth:
code = 400
result = general_message(code, "no identity", "您不是管理员，没有权限做此操作")
return Response(result, status=code)
try:
user_ids = request.data.get('user_ids', None)
identitys = request.data.get('identitys', None)
identitys = identitys.split(',') if identitys else []
if not user_ids:
raise ParamsError("用户名为空")
code = 200
team = team_services.get_tenant_by_tenant_name(tenant_name=team_name, exception=True)
user_ids = user_ids.split(',')
if identitys:
team_services.add_user_to_team(request=request, tenant=team, user_ids=user_ids, identitys=identitys)
result = general_message(code, "success", "用户添加到{}成功".format(team_name))
else:
team_services.add_user_to_team(request=request, tenant=team, user_ids=user_ids, identitys='access')
result = general_message(code, "success", "用户添加到{}成功".format(team_name))
except PermTenantsExistError as e:
code = 400
result = general_message(code, "permtenant exist", e.message)
except ParamsError as e:
logging.exception(e)
code = 400
result = general_message(code, "params user_id is empty", e.message)
except UserNotExistError as e:
code = 400
result = general_message(code, "user not exist", e.message)
except Tenants.DoesNotExist as e:
code = 400
logger.exception(e)
result = general_message(code, "tenant not exist", "{}团队不存在".format(team_name))
except UserExistError as e:
logger.exception(e)
code = 400
result = general_message(code, "user already exist", e.message)
except Exception as e:
code = 500
logger.exception(e)
print(str(e))
result = general_message(code, "system error", "系统异常")
return Response(result, status=code)
