def un_relation(self, request, *args, **kwargs):
data = request.data
parent_table_id = data.get("parent_table_id")
child_table_id = data.get("child_table_id")
if not parent_table_id or not child_table_id:
return json_error_response(
"parent_table_id and child_table_id 是必传参数.")
classify_relation_obj = OperateInstance.get_table_relation(
parent_table_id, child_table_id)
if not classify_relation_obj:
return json_error_response(
f"找不到parent_table_id为:{parent_table_id}, child_table_id为: {child_table_id} 关系记录"
)
# 修改 child_classify_obj 的值
child_classify_obj = OperateInstance.get_table_classify(child_table_id)
if child_classify_obj.is_forbid_bind:
child_classify_obj.is_forbid_bind = False
child_classify_obj.save()
classify_relation_obj.delete()
return json_ok_response("解除关联成功")
def un_relation(self, request, *args, **kwargs):
parent_asset_id = request.data.get("parent_asset_id")
child_asset_id = request.data.get("child_asset_id")
if not parent_asset_id or not child_asset_id:
return json_error_response(
"parent_asset_id and child_asset_id 是必传参数")
asset_relation_obj = OperateInstance.get_abs_asset_relation(
parent_asset_id, child_asset_id)
if not asset_relation_obj:
return json_error_response("未查询到资产绑定记录, 请检查后重试.")
try:
record(
"un_relation",
asset_relation_obj.parent_asset,
asset_relation_obj.child_asset,
request,
)
except Exception as e:
return json_error_response(f"日志记录出错: {str(e)}")
if not asset_relation_obj.table_relation.is_foreign_key:
asset_relation_obj.child_asset.is_forbid_bind = False
asset_relation_obj.child_asset.save()
asset_relation_obj.delete()
return json_ok_response()
def update(self, request, *args, **kwargs):
instance = self.get_object()
data = request.data
# 判断如果更换 table_classify_id 当前 instance 是否存在资产
if instance.table_classify.id != data[
"table_classify"] and OperateInstance.get_all_asset(
instance.table_classify.id):
return json_error_response("分类表已经存在资产, 字段表不允许更换主类.")
# 判断更换的 table_classify 是否是 主分类表
if not OperateInstance.get_table_classify(data["table_classify"]).pid:
return json_error_response("指定的分类表为主分类,主分类无法设置表字段.")
# 检查数据
try:
check_field(data)
except Exception as e:
return json_error_response(f"数据校验出错: {str(e)}")
print(data)
partial = kwargs.pop("partial", False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=data, partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
if getattr(instance, "_prefetched_objects_cache", None):
instance._prefetched_objects_cache = {}
return json_ok_response(data=serializer.data)
def update(self, request, *args, **kwargs):
instance = self.get_object()
data = request.data
# data = json.loads(json.dumps(request.data))
pid = data.get("pid")
# 判断是否存在PID
if pid:
# 查询 pid = instance.id 的表, 如果存在则报错.
if OperateInstance.get_children_table_classify(instance.id):
return json_error_response("无法修改, 此类型表存在子分类表.")
# 获取要指定为主类的实例, 并判断是否为主类 也就是 PID == Null
parent_table_classify = OperateInstance.get_table_classify(pid)
if not parent_table_classify or parent_table_classify.pid:
return json_error_response("指定的 pid 不存在或者不是主分类表.")
if data.get("icon"):
if not isinstance(data.get("icon"), InMemoryUploadedFile):
del data["icon"]
serializer = self.get_serializer(instance,
data=data,
partial=kwargs.pop("partial", False))
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
if getattr(instance, "_prefetched_objects_cache", None):
instance._prefetched_objects_cache = {}
return json_ok_response(serializer.data)
def update(self, request, *args, **kwargs):
instance = self.get_object()
try:
data = check_data(request.data, instance)
except ValueError as e:
return json_error_response(f"数据校验出错: {str(e)}")
if (data.get("table_classify")
and data.get("table_classify") != instance.table_classify.id):
return json_error_response("数据不可修改类型, 如需更换请进行删除.")
try:
record("update_data", None, instance, request)
except Exception as e:
return json_error_response(f"日志记录出错: {str(e)}")
partial = kwargs.pop("partial", False)
serializer = self.get_serializer(instance, data=data, partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
if getattr(instance, "_prefetched_objects_cache", None):
instance._prefetched_objects_cache = {}
return json_ok_response(serializer.data)
def create(self, request, *args, **kwargs):
table_classify_obj = OperateInstance.get_table_classify(
request.data["table_classify"])
# 判断 table_classify实例是否存在并且不是主分类
if not table_classify_obj or not table_classify_obj.pid:
return json_error_response(
"table_classify实例不存在或者table_classify实例为主分类,主分类不允许创建字段表.")
try:
check_field(request.data)
except Exception as e:
return json_error_response(f"数据校验出错: {str(e)}")
return super(TableFieldViewSet, self).create(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
user = request.user
try:
u = models.UserProfile.objects.get(pk=user.pk)
except models.UserProfile.DoesNotExist:
return json_error_response(message="not found")
s = serializers.UserProfileModelSerializer(u)
return json_ok_response(data=s.data)
def post(self, request):
username = request.user.username
serializer = serializers.HasPermSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
path = serializer.data.get("path")
method = serializer.data.get("method")
return response.json_ok_response() \
if verify_permission(username, path, method) else response.json_error_response("没有权限")
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
try:
record("delete_data", instance, None, request)
except Exception as e:
return json_error_response(f"日志记录出错: {str(e)}")
instance.delete()
return json_ok_response("删除成功")
def create(self, request, *args, **kwargs):
data = request.data
pid = data.get("pid")
# 如果新建数据存在PID
if pid:
# 查询 id = pid 的实例, 如果实例的PID不为Null则返回错误
if OperateInstance.get_table_classify(pid).pid:
return json_error_response(f"指定的pid:({pid}) 不是主分类表.")
return super(TableClassifyViewSet,
self).create(request, *args, **kwargs)
def create(self, request, *args, **kwargs):
try:
data = check_data(request.data, None)
except Exception as e:
return json_error_response(f"数据校验出错: {str(e)}")
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
self.get_success_headers(serializer.data)
return json_ok_response(serializer.data)
def create(self, request, *args, **kwargs):
serializer = serializers.UserRoleBindSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
for role in serializer.validated_data['role']:
if len(
models.RoleBind.objects.filter(
user=serializer.validated_data['user'], role=role)):
return response.json_error_response(
{'role': ["用户已绑定<{}>角色".format(role.id)]})
serializer.create(serializer.validated_data)
return response.json_api_response(0, None, "创建成功")
def list(self, request, *args, **kwargs):
table_classify_id = request.query_params.get("table_classify_id")
if not table_classify_id:
return json_error_response("资产查询只能通过分类ID查询.")
table_obj = OperateInstance.get_table_classify(table_classify_id)
if not table_obj:
return json_error_response("找不到指定的模型表")
table_field_obj = OperateInstance.get_table_field(table_classify_id)
if not table_field_obj:
return json_error_response("找不到分类表的字段表")
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
data = {
"data": serializer.data,
"fields": table_field_obj.fields,
"rules": table_field_obj.rules,
"patent_classify_name":
table_field_obj.table_classify.pid.name,
"classify_name": table_field_obj.table_classify.name,
"classify_id": table_field_obj.table_classify.id,
}
return self.get_paginated_response(data)
serializer = self.get_serializer(queryset, many=True)
data = {
"data": serializer.data,
"fields": table_field_obj.fields,
"rules": table_field_obj.rules,
"patent_classify_name": table_field_obj.table_classify.pid.name,
"classify_name": table_field_obj.table_classify.name,
"classify_id": table_field_obj.table_classify.id,
}
return json_ok_response(data)
def filter_user(self, request, pk=None):
logger.debug("Action pk: {}.".format(pk))
try:
instance = models.Organization.objects.get(pk=pk)
except models.Organization.DoesNotExist:
return json_error_response(message="pk: {} not found.".format(pk))
u_ids = []
query_set = instance.get_descendants(include_self=True)
for q in query_set:
_qs = q.userprofile_set.all()
if not _qs:
continue
u_ids.extend([u.pk for u in _qs])
users = models.UserProfile.objects.filter(pk__in=u_ids)
s = serializers.UserProfileModelSerializer(users, many=True)
return json_ok_response(data=s.data)
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
# 如果没有 pid 则为主分类表
if not instance.pid:
child_table_all = OperateInstance.get_children_table_classify(
instance.id)
if child_table_all:
return json_error_response("如果删除主类型请先删除实体模型表.")
# 清理关联表
table_relation = OperateInstance.get_parent_table_relation(instance.id)
if table_relation:
for inc in table_relation:
if inc.child_table.is_forbid_bind:
inc.delete()
instance.delete()
return json_ok_response("删除成功")
def relation(self, request, *args, **kwargs):
parent_asset_id = request.data.get("parent_asset_id")
child_asset_id = request.data.get("child_asset_id")
if not parent_asset_id or not child_asset_id:
return json_error_response(
"parent_asset_id and child_asset_id 是必传参数")
parent_asset_obj = OperateInstance.get_asset(parent_asset_id)
child_asset_obj = OperateInstance.get_asset(child_asset_id)
# 判断对应资产是否存在
if not parent_asset_obj or not child_asset_obj:
return json_error_response("找不到指定ID的资产")
table_relation_obj = OperateInstance.get_table_relation(
parent_asset_obj.table_classify.id,
child_asset_obj.table_classify.id)
# 判断分类关系绑定表是否存在
if not table_relation_obj:
return json_error_response("未查询到分类关系绑定表, 请先进行绑定在进行资产绑定操作.")
is_foreign_key = table_relation_obj.is_foreign_key
# 判断是否为 OneToOne 如果是则判断是否存在绑定记录
if not is_foreign_key:
asset_relation_obj = OperateInstance.get_child_asset_relation(
table_relation_obj.id, child_asset_obj.id)
if asset_relation_obj:
return json_error_response(
"类型表关联模式为: OneToOne, 子资产数据已经被绑定无法进行二次绑定.")
try:
new_asset_relation = AssetsRelation.objects.create(
parent_asset=parent_asset_obj,
child_asset=child_asset_obj,
table_relation=table_relation_obj,
)
new_asset_relation.save()
except Exception as e:
return json_error_response(f"数据创建出错: {str(e)}")
if not is_foreign_key:
child_asset_obj.is_forbid_bind = True
child_asset_obj.save()
try:
record("relation", parent_asset_obj, child_asset_obj, request)
except Exception as e:
return json_error_response(f"日志记录出错: {str(e)}")
return json_ok_response("资产数据绑定成功")
def relation(self, request, *args, **kwargs):
data = request.data
parent_table_id = data.get("parent_table_id")
child_table_id = data.get("child_table_id")
if not parent_table_id or not child_table_id:
return json_error_response(
"parent_table_id and child_table_id 是必传参数.")
parent_classify = OperateInstance.get_table_classify(parent_table_id)
child_classify = OperateInstance.get_table_classify(child_table_id)
# 验证表是否存在
if not parent_classify or not child_classify:
return json_error_response("parent分类表或者child分类表不存在")
# 验证 是否有
if not parent_classify.pid or not child_classify.pid:
return json_error_response("parent分类表或者child分类表是主分类表, 不允许进行绑定操作.")
# 验证 child 和 parent 是否为同一个表
if parent_classify.id == child_classify.id:
return json_error_response("不支持自关联.")
# 验证 是否禁止绑定.
if child_classify.is_forbid_bind:
return json_error_response("child表,禁止绑定操作.")
# 验证是否存在字段表
parent_field = OperateInstance.get_table_field(parent_table_id)
child_field = OperateInstance.get_table_field(child_table_id)
if not parent_field or not child_field:
return json_error_response("parent类型表或者child类型表没有字段表")
table_relation_obj = TableRelation.objects.create(
parent_table_id=parent_table_id,
child_table_id=child_table_id,
is_foreign_key=data.get("is_foreign_key"),
)
if request.data.get("is_forbid_bind"):
child_classify.is_forbid_bind = True
child_classify.save()
table_relation_obj.save()
return json_ok_response("关联成功")
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
if OperateInstance.get_all_asset(instance.table_classify.id):
return json_error_response("删除字段存在数据无法进行删除操作")
instance.delete()
return json_ok_response()
