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):
serializer = CreateTeamReqSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
team_data = serializer.data
team_data["creater"] = self.user.user_id
team_data["enterprise_id"] = self.enterprise.enterprise_id
en = self.enterprise
if not en:
raise serializers.ValidationError("指定企业不存在")
region = None
if team_data.get("region", None):
region = region_services.get_region_by_region_name(
team_data.get("region"))
if not region:
raise ErrRegionNotFound
try:
user = user_services.get_user_by_user_id(
team_data.get("creater", 0))
except UserNotExistError:
user = request.user
team = team_services.create_team(user,
en,
team_alias=team_data["tenant_name"])
if region:
region_services.create_tenant_on_region(
self.enterprise.enterprise_id, team.tenant_name,
region.region_name)
re = TeamBaseInfoSerializer(team)
return Response(re.data, status=status.HTTP_201_CREATED)
def post(self, request, *args, **kwargs):
"""
新建团队
---
parameters:
- name: team_alias
description: 团队名
required: true
type: string
paramType: body
- name: useable_regions
description: 可用数据中心 ali-sh,ali-hz
required: false
type: string
paramType: body
"""
try:
user = request.user
team_alias = request.data.get("team_alias", None)
useable_regions = request.data.get("useable_regions", "")
regions = []
if not team_alias:
result = general_message(400, "failed", "团队名不能为空")
return Response(result, status=400)
if useable_regions:
regions = useable_regions.split(",")
if Tenants.objects.filter(tenant_alias=team_alias, enterprise_id=user.enterprise_id).exists():
result = general_message(400, "failed", "该团队名已存在")
return Response(result, status=400)
else:
enterprise = console_enterprise_service.get_enterprise_by_enterprise_id(self.user.enterprise_id)
if not enterprise:
return Response(general_message(500, "user's enterprise is not found", "无企业信息"), status=500)
team = team_services.create_team(self.user, enterprise, regions, team_alias)
for r in regions:
try:
region_services.create_tenant_on_region(enterprise.enterprise_id, team.tenant_name, r)
except ServiceHandleException as e:
logger.exception(e)
except Exception as e:
logger.exception(e)
return Response(general_message(200, "success", "团队添加成功", bean=team.to_dict()))
except TenantExistError as e:
logger.exception(e)
code = 400
result = general_message(code, "team already exists", "该团队已存在")
return Response(result, status=code)
except NoEnableRegionError as e:
logger.exception(e)
code = 400
result = general_message(code, "no enable region", "无可用数据中心")
return Response(result, status=code)
def post(self, request, team_id):
serializer = TeamRegionReqSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
team_data = serializer.data
region = None
if team_data.get("region", None):
region = region_services.get_region_by_region_name(team_data.get("region"))
if not region:
raise ErrRegionNotFound
team = team_services.get_team_by_team_id(team_id)
region_services.create_tenant_on_region(self.enterprise.enterprise_id, team.tenant_name, region.region_name)
re = TeamBaseInfoSerializer(team)
return Response(re.data, status=status.HTTP_201_CREATED)
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 post(self, request):
serializer = CreateTeamReqSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
team_data = serializer.data
en = enterprise_services.get_enterprise_by_enterprise_id(request.data.get("enterprise_id"))
if not en:
raise serializers.ValidationError("指定企业不存在")
region = None
if team_data.get("region", None):
region = region_services.get_region_by_region_name(team_data.get("region"))
if not region:
raise serializers.ValidationError("指定数据中心不存在")
try:
user = user_services.get_user_by_user_id(team_data.get("creater", 0))
except UserNotExistError:
user = request.user
code, msg, team = team_services.create_team(user, en, team_alias=team_data["tenant_name"])
if code == 200 and region:
code, message, bean = region_services.create_tenant_on_region(team.tenant_name, region.region_name)
if code != 200:
team.delete()
raise serializers.ValidationError("数据中心创建团队时发生错误")
if code == 200:
re = TeamBaseInfoSerializer(team)
return Response(re.data, status=status.HTTP_201_CREATED)
else:
return Response(None, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def __init_and_create_user_tenant(self, user, enterprise):
# 创建租户信息
code, msg, team = team_services.create_team(user, enterprise)
if code != 200:
logger.debug("account.login", "create tenant error")
return code, msg, team
# 创建用户在团队的权限
perm_info = {
"user_id": user.user_id,
"tenant_id": team.ID,
"identity": "owner",
"enterprise_id": enterprise.pk
}
perm_services.add_user_tenant_perm(perm_info)
# 创建用户在企业的权限
user_services.make_user_as_admin_for_enterprise(
user.user_id, enterprise.enterprise_id)
# 为团队开通默认数据中心并在数据中心创建租户
code, msg, tenant_region = region_services.create_tenant_on_region(
team.tenant_name, team.region)
if code != 200:
logger.debug("account.login", "create teanant on region error")
return code, msg, team
# 如果没有领过资源包，为默认开通的数据中心领取免费资源包
result = region_services.get_enterprise_free_resource(
tenant_region.tenant_id, enterprise.enterprise_id,
tenant_region.region_name, user.nick_name)
logger.debug(
"account.login", "get free resource on [{}] to team {}: {}".format(
tenant_region.region_name, team.tenant_name, result))
user.is_active = True
user.save()
return code, msg, team
def post(self, request):
"""
初始化团队和数据中心信息
---
parameters:
- name: team_alias
description: 团队别名
required: true
type: string
paramType: form
- name: region_name
description: 数据中心名称
required: true
type: string
paramType: form
"""
try:
team_alias = request.data.get("team_alias", None)
region_name = request.data.get("region_name", None)
if not team_alias:
return Response(general_message(400, "team alias is null", "团队名称不能为空"), status=400)
if not region_name:
return Response(general_message(400, "region name is null", "请选择数据中心"), status=400)
r = re.compile('^[a-zA-Z0-9_\\-\\u4e00-\\u9fa5]+$')
if not r.match(team_alias):
return Response(general_message(400, "team alias is not allow", "组名称只支持中英文下划线和中划线"), status=400)
team = team_services.get_team_by_team_alias(team_alias)
if team:
return Response(general_message(409, "region alias is exist", "团队名称{0}已存在".format(team_alias)), status=409)
region = region_repo.get_region_by_region_name(region_name)
if not region:
return Response(general_message(404, "region not exist", "需要开通的数据中心{0}不存在".format(region_name)), status=404)
enterprise = console_enterprise_service.get_enterprise_by_enterprise_id(self.user.enterprise_id)
if not enterprise:
return Response(general_message(404, "user's enterprise is not found", "无法找到用户所在的数据中心"))
team = team_services.create_team(self.user, enterprise, [region_name], team_alias)
# 为团队开通默认数据中心并在数据中心创建租户
tenant_region = region_services.create_tenant_on_region(enterprise.enterprise_id, team.tenant_name, team.region)
# 公有云，如果没有领过资源包，为开通的数据中心领取免费资源包
if settings.MODULES.get('SSO_LOGIN'):
result = region_services.get_enterprise_free_resource(tenant_region.tenant_id, enterprise.enterprise_id,
tenant_region.region_name, self.user.nick_name)
logger.debug("get free resource on [{}] to team {}: {}".format(tenant_region.region_name, team.tenant_name,
result))
self.user.is_active = True
self.user.save()
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_id):
serializer = TeamRegionReqSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
team_data = serializer.data
region = None
if team_data.get("region", None):
region = region_services.get_region_by_region_name(team_data.get("region"))
if not region:
raise serializers.ValidationError("指定数据中心不存在")
team = team_services.get_team_by_team_id(team_id)
code, message, bean = region_services.create_tenant_on_region(team.tenant_name, region.region_name)
if code != 200:
raise serializers.ValidationError("数据中心创建团队时发生错误")
if code == 200:
re = TeamBaseInfoSerializer(team)
return Response(re.data, status=status.HTTP_201_CREATED)
else:
return Response(None, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, *args, **kwargs):
"""
新建团队
---
parameters:
- name: team_alias
description: 团队名
required: true
type: string
paramType: body
- name: useable_regions
description: 可用数据中心 ali-sh,ali-hz
required: false
type: string
paramType: body
"""
try:
user = request.user
team_alias = request.data.get("team_alias", None)
useable_regions = request.data.get("useable_regions", "")
regions = []
if not team_alias:
result = general_message(400, "failed", "团队名不能为空")
return Response(result, status=400)
if useable_regions:
regions = useable_regions.split(",")
if Tenants.objects.filter(tenant_alias=team_alias).exists():
result = general_message(400, "failed", "该团队名已存在")
return Response(result, status=400)
else:
enterprise = enterprise_services.get_enterprise_by_enterprise_id(self.user.enterprise_id)
if not enterprise:
return Response(general_message(500, "user's enterprise is not found"), status=500)
code, msg, team = team_services.create_team(self.user, enterprise, regions, team_alias)
role_obj = role_repo.get_default_role_by_role_name(role_name="owner", is_default=True)
# 创建用户在团队的权限
perm_info = {
"user_id": user.user_id,
"tenant_id": team.ID,
"enterprise_id": enterprise.pk,
# 创建团队时给创建用户添加owner的角色
"role_id": role_obj.pk
}
perm_services.add_user_tenant_perm(perm_info)
for r in regions:
code, msg, tenant_region = region_services.create_tenant_on_region(team.tenant_name, r)
if code != 200:
return Response(general_message(code, "add team error", msg), status=code)
return Response(general_message(200, "success", "团队添加成功", bean=team.to_dict()))
except TenantExistError as e:
logger.exception(e)
code = 400
result = general_message(code, "team already exists", "该团队已存在")
return Response(result, status=code)
except NoEnableRegionError as e:
logger.exception(e)
code = 400
result = general_message(code, "no enable region", "无可用数据中心")
return Response(result, status=code)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def post(self, request, *args, **kwargs):
"""
添加团队
---
parameters:
- name: tenant_name
description: 团队名
required: true
type: string
paramType: form
- name: enterprise_id
description: 企业ID
required: true
type: string
paramType: form
- name: useable_regions
description: 可用数据中心 ali-sh,ali-hz
required: false
type: string
paramType: form
"""
sid = None
try:
tenant_name = request.data.get("tenant_name", None)
if not tenant_name:
return Response(
generate_result("1003", "team name is none", "团对名称不能为空"))
enterprise_id = request.data.get("enterprise_id", None)
if not enterprise_id:
return Response(
generate_result("1003", "enterprise id is none",
"企业ID不能为空"))
enter = enterprise_services.get_enterprise_by_enterprise_id(
enterprise_id)
if not enter:
return Response(
generate_result("0404", "enterprise not found",
"企业在云帮不存在"))
team = console_team_service.get_team_by_team_alias_and_eid(
tenant_name, enterprise_id)
if team:
return Response(
generate_result("0409", "team alias is exist",
"团队别名{0}在该企业已存在".format(tenant_name)))
user = console_user_service.get_enterprise_first_user(
enter.enterprise_id)
if not user:
return Response(
generate_result("0412", "enterprise has no user",
"企业下不存在任何用户"))
useable_regions = request.data.get("useable_regions", "")
logger.debug("team name {0}, usable regions {1}".format(
tenant_name, useable_regions))
regions = []
if useable_regions:
regions = useable_regions.split(",")
# 开启保存点
sid = transaction.savepoint()
code, msg, team = console_team_service.create_team(
user, enter, regions, tenant_name)
# 创建用户在团队的权限
perm_info = {
"user_id": user.user_id,
"tenant_id": team.ID,
"identity": "owner",
"enterprise_id": enter.pk
}
console_perm_service.add_user_tenant_perm(perm_info)
for r in regions:
code, msg, tenant_region = console_region_service.create_tenant_on_region(
team.tenant_name, r)
if code != 200:
logger.error(msg)
if sid:
transaction.savepoint_rollback(sid)
return Response(generate_result("0500", "add team error",
msg),
status=code)
transaction.savepoint_commit(sid)
bean = {
"tenant_name": team.tenant_name,
"tenant_id": team.tenant_id,
"tenant_alias": team.tenant_alias,
"user_num": 0
}
result = generate_result("0000", "success", "租户添加成功", bean=bean)
except TenantOverFlowError as e:
result = generate_result("7001", "tenant over flow",
"{}".format(e.message))
except TenantExistError as e:
result = generate_result("7002", "tenant exist",
"{}".format(e.message))
except NoEnableRegionError as e:
result = generate_result("7003", "no enable region",
"{}".format(e.message))
except Exception as e:
logger.exception(e)
if sid:
transaction.savepoint_rollback(sid)
result = generate_error_result()
return Response(result)
def post(self, request, *args, **kwargs):
"""
注册用户、需要先访问captcha路由来获取验证码
---
parameters:
- name: user_name
description: 用户名
required: true
type: string
paramType: body
- name: email
description: 邮箱
required: true
type: string
paramType: body
- name: password
description: 密码，最少八位
required: true
type: string
paramType: body
- name: password_repeat
description: 确认密码
required: true
type: string
paramType: body
- name: captcha_code
description: 验证码
required: true
type: string
paramType: body
- name: register_type
description: 注册方式 暂: 邀请注册 invitation 其它方式暂无 有拓展再修改
required: false
type: string
paramType: body
- name: value
description: 数值 此处需要 team_id
required: false
type: string
paramType: body
"""
try:
import copy
querydict = copy.copy(request.data)
captcha_code = request.session.get("captcha_code")
querydict.update({u'real_captcha_code': captcha_code})
client_ip = request.META.get("REMOTE_ADDR", None)
register_form = RegisterForm(querydict)
if register_form.is_valid():
nick_name = register_form.cleaned_data["user_name"]
email = register_form.cleaned_data["email"]
password = register_form.cleaned_data["password"]
# 创建一个用户
user_info = dict()
user_info["email"] = email
user_info["nick_name"] = nick_name
user_info["client_ip"] = client_ip
user_info["is_active"] = 1
user = Users(**user_info)
user.set_password(password)
user.save()
enterprise = enterprise_services.get_enterprise_first()
if not enterprise:
enterprise = enterprise_services.create_enterprise()
# 创建用户在企业的权限
user_services.make_user_as_admin_for_enterprise(
user.user_id, enterprise.enterprise_id)
user.enterprise_id = enterprise.enterprise_id
user.save()
try:
if Users.objects.count() == 1:
SuperAdminUser.objects.create(user_id=user.user_id)
enterprise = enterprise_services.get_enterprise_first()
register_type = request.data.get("register_type", None)
value = request.data.get("value", None)
if register_type == "invitation":
perm = perms_repo.add_user_tenant_perm(
perm_info={
"user_id": user.user_id,
"tenant_id": value,
"identity": "viewer",
"enterprise_id": enterprise.ID
})
if not perm:
result = general_message(400, "invited failed",
"团队关联失败，注册失败")
return Response(result, status=400)
else:
team_alias = "{0}的团队".format(nick_name)
regions = region_services.get_open_regions()
if not regions:
result = general_message(400, "failed", "无可用数据中心")
return Response(result, status=400)
region_name = [regions[0].region_name]
region_list = [r.region_name for r in regions]
code, msg, tenant = team_services.create_team(
user, enterprise, region_list)
# code, msg, tenant = team_services.add_team(team_alias=team_alias, user=user,
# region_names=region_name)
if tenant:
perm = perms_repo.add_user_tenant_perm(
perm_info={
"user_id": user.user_id,
"tenant_id": tenant.ID,
"identity": "owner",
"enterprise_id": enterprise.ID
})
code, msg, tenant_region = region_services.create_tenant_on_region(
tenant.tenant_name, tenant.region)
if code != 200:
return Response(general_message(
code, "register fail", msg),
status=code)
data = dict()
data["user_id"] = user.user_id
data["nick_name"] = user.nick_name
data["email"] = user.email
data["enterprise_id"] = user.enterprise_id
data["creater"] = tenant.creater
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
data["token"] = token
result = general_message(200,
"success",
"注册成功",
bean=data)
return Response(result, status=200)
else:
result = general_message(code=code,
msg="failed",
msg_show=msg)
return Response(result, status=400)
data = dict()
data["user_id"] = user.user_id
data["nick_name"] = user.nick_name
data["email"] = user.email
data["enterprise_id"] = user.enterprise_id
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
data["token"] = token
result = general_message(200,
"register success",
"注册成功",
bean=data)
response = Response(result, status=200)
return response
except Exception as e:
logger.exception(e)
user.delete()
result = general_message(500, "failed", "团队初始化错误")
return Response(result, status=500)
else:
error = {
"error":
list(json.loads(
register_form.errors.as_json()).values())[0][0].get(
"message", "参数错误")
}
result = general_message(400, "failed",
"{}".format(error["error"]))
return Response(result, status=400)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def post(self, request, *args, **kwargs):
"""
创建租户并开通数据中心
---
parameters:
- name: region_name
description: 数据中心名称
required: true
type: string
paramType: form
- name: team_alias
description: 团队名称
required: true
type: string
paramType: form
"""
try:
team = None
team_alias = request.data.get("team_alias", None)
region_name = request.data.get("region_name", None)
need_creare_team = False
if not team_alias:
need_creare_team = True
team_alias = "{0}的团队".format(request.user.nick_name)
else:
team = team_services.get_team_by_team_alias(team_alias)
if not team:
return self.error_response(code=status.HTTP_404_NOT_FOUND, msg="team is not found",
msg_show="团队{0}不存在".format(team_alias))
if not region_name:
return self.error_response(code=status.HTTP_406_NOT_ACCEPTABLE, msg='region name is null!',
msg_show="数据中心名称不能为空")
region = region_repo.get_region_by_region_name(region_name)
if not region:
return self.error_response(code=status.HTTP_404_NOT_FOUND, msg="region is not found",
msg_show="数据中心{0}不存在".format(region_name))
enterprise = enterprise_services.get_enterprise_by_enterprise_id(request.user.enterprise_id)
if not enterprise:
return self.error_response(code=status.HTTP_404_NOT_FOUND, msg="enterprise is not found",
msg_show="用户所在企业不存在")
if need_creare_team:
code, msg, team = team_services.create_team(request.user, enterprise, [region_name], team_alias)
if not code:
return self.error_response(code=code, msg="create team error",
msg_show="初始化团队失败")
perm_info = {
"user_id": request.user.user_id,
"tenant_id": team.ID,
"identity": "owner",
"enterprise_id": enterprise.pk
}
perm_services.add_user_tenant_perm(perm_info)
# 创建用户在企业的权限
user_services.make_user_as_admin_for_enterprise(request.user.user_id, enterprise.enterprise_id)
# 为团队开通默认数据中心并在数据中心创建租户
code, msg, tenant_region = region_services.create_tenant_on_region(team.tenant_name, team.region)
if code != 200:
if not code:
return self.error_response(code=code, msg="create tenant on region error",
msg_show="数据中心创建团队失败")
request.user.is_active = True
request.user.save()
result = self.success_response(team.to_dict())
else:
code, msg, tenant_region = region_services.create_tenant_on_region(team.tenant_name, region_name)
if code != 200:
if not code:
return self.error_response(code=code, msg="create tenant on region error",
msg_show="数据中心创建团队失败")
request.user.is_active = True
request.user.save()
result = self.success_response(team.to_dict())
except Exception as e:
logger.exception(e)
result = self.error_response(status.HTTP_500_INTERNAL_SERVER_ERROR, "system error", "系统异常")
return result
