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()