def get(self, request):
role_bind_user_qs = request.user.role_bind.all()
for rb in role_bind_user_qs:
if rb.role.name == settings.ADMIN_ROLE:
return response.json_ok_response(self._get_admin_route())
router_chain = chain(
*[rb.role.router.all() for rb in role_bind_user_qs])
route_qs = models.Router.objects.filter(
pk__in=[r.id for r in router_chain])
ret = self._get_children_route(route_qs)
return response.json_ok_response(ret)
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 tree(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
serializer = self.get_serializer(queryset, many=True)
data = []
for item in json.loads(json.dumps(serializer.data)):
if not item["pid"]:
for dic in data:
if dic["id"] == item["id"]:
break
else:
item["children"] = []
data.append(item)
else:
for i, dic in enumerate(data):
if dic["id"] == item["pid"]:
data[i]["children"].append(item)
break
else:
parent_data = self.get_serializer(
OperateInstance.get_table_classify(item["pid"]))
tmp_data = json.loads(json.dumps(parent_data.data))
tmp_data["children"] = []
tmp_data["children"].append(item)
data.append(tmp_data)
return json_ok_response(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 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 search(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
serializer = self.get_serializer(queryset, many=True)
data = []
for item in json.loads(json.dumps(serializer.data)):
for i, dic in enumerate(data):
if item["table_classify"] in dic.values():
item["data"]["id"] = item["id"]
data[i]["data"].append(item["data"])
break
else:
tmp = {}
classify = OperateInstance.get_table_classify(
item["table_classify"])
tmp["classify_id"] = classify.id
tmp["classify_name"] = classify.name
tmp["patent_classify_name"] = classify.pid.name
tmp["fields"] = classify.fields.fields
item["data"]["id"] = item["id"]
tmp["data"] = [item["data"]]
data.append(tmp)
return json_ok_response(data)
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 retrieve(self, request, *args, **kwargs):
instance = self.get_object()
serializer = self.get_serializer(instance)
data = serializer.data
field_obj = OperateInstance.get_table_field(instance.id)
if field_obj:
data["rules"] = field_obj.rules
data["field_id"] = field_obj.id
data["fields"] = field_obj.fields
else:
data["field_id"] = None
data["rules"] = None
data["fields"] = None
children_all = OperateInstance.get_table_relation_list(instance.id)
data["children"] = []
data["relevant"] = []
if children_all:
for item in children_all:
dic = self.get_serializer(item.child_table).data
dic["parent_name"] = item.child_table.pid.name
dic["is_foreign_key"] = item.is_foreign_key
data["children"].append(dic)
relevant_all = OperateInstance.get_table_relation_list_c(instance.id)
if relevant_all:
for item in relevant_all:
dic = self.get_serializer(item.parent_table).data
dic["parent_name"] = item.parent_table.pid.name
dic["is_foreign_key"] = item.is_foreign_key
data["relevant"].append(dic)
return json_ok_response(data)
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 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 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 classify(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset()).filter(pid=None)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return json_ok_response(serializer.data)
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 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 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 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 retrieve(self, request, *args, **kwargs):
instance = self.get_object()
serializer = self.get_serializer(instance)
table_field_obj = OperateInstance.get_table_field(
instance.table_classify.id)
data = OrderedDict()
data["classify_name"] = instance.table_classify.name
data["classify_id"] = instance.table_classify.id
data["patent_classify_name "] = instance.table_classify.pid.name
data["fields"] = table_field_obj.fields
data["rules"] = table_field_obj.rules
data["data"] = serializer.data
data["children"] = OperateInstance.get_p_relation_asset(
instance.id, instance.table_classify.id)
data["relevant"] = OperateInstance.get_c_relation_asset(
instance.id, instance.table_classify.id)
return json_ok_response(data)
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()
# 如果没有 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 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 menu(self, request):
parents_qs = self.queryset.filter(isParent=True, parent=None)
return response.json_ok_response(self._get_children_route(parents_qs))
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()