Files
ZERO_CODE/ZeroCodeProject/apis/ZeroCodeMain/BaseApi/views.py

271 lines
11 KiB
Python
Raw Normal View History

2026-01-11 00:11:34 +08:00
import re
from io import BytesIO
from ZeroCodeMain.settings import BASE_DIR
from django.http import JsonResponse
from rest_framework import status
from users.models import Permissions
from users.serializers import PermissionsSerializer
from django.db.models import Q
from rest_framework.response import Response
from rest_framework.views import APIView
import requests
import os
from ZeroCodeMain.settings import BASE_DIR
from depend_main.functions.abstractFactoryFunction import create_class, create_class_from_db
from BaseApi.models import *
from dependency.base.utils import *
from .permission import NormalPermissionCheck
config_file_path = os.path.join(BASE_DIR, 'dependency', 'api_config', 'project_info.json')
with open(config_file_path, "r") as config_file:
config = json.load(config_file)
# 运行前检查
# 检测并确认所有数据库中的model都已经注册并且创建
# TODO 队列检查初始化,若已经存在剔除队列
try:
instance = Model.objects.all()
for item in instance:
model_instance = item.get_django_model()
except Exception as e:
print(e)
# Create your views here.
class GetAllModelList(APIView):
def get(self, request):
instance_in = Model.objects.all()
get_serializers = build_serializers(Model.__name__, Model, {}, False)
datas = get_serializers(instance_in, many=True).data
return Response({
"datas": datas,
})
class GetModelDetail(APIView):
def get(self, request):
instance_in = ModelField.objects.filter(model_id=request.GET["id"])
get_serializers = build_serializers(ModelField.__name__, ModelField, {}, False)
datas = get_serializers(instance_in, many=True).data
return Response({
"datas": datas,
})
def post(self, request):
for add_item in request.data:
if "id" not in add_item:
add_item["model"] = Model.objects.get(pk=add_item["model"])
ModelField.objects.create(**add_item)
else:
add_item["model"] = add_item["model"]["id"]
ins = ModelField.objects.get(pk=add_item["id"])
get_serializers = build_serializers(ModelField.__name__, ModelField, {}, False)
serializers = get_serializers(ins, data=add_item, partial=True)
if serializers.is_valid():
serializers.save()
return Response({"msg": "success"})
class GetModelSettingList(APIView):
def get(self, request):
settings_list = []
instance_in = ModelField.objects.filter(model_id=request.GET["id"])
get_serializers = build_serializers(ModelField.__name__, ModelField, {}, False)
datas = get_serializers(instance_in, many=True).data
for items in datas:
settings_item = ModelSetting.objects.filter(field_id=items["id"])
settings_serializers = build_serializers(ModelSetting.__name__, ModelSetting, {}, False)
settings_datas = settings_serializers(settings_item, many=True).data
settings_list.extend(settings_datas)
return Response({"datas": settings_list})
def post(self, request):
model_id = None
for add_item in request.data:
if "id" not in add_item:
add_item["field"] = ModelField.objects.get(pk=add_item["field"]["id"])
created_instance = ModelSetting.objects.create(**add_item)
model_id = ModelField.objects.filter(pk=created_instance.field_id).first().model_id
else:
model_id = ModelField.objects.filter(pk=add_item["field"]["id"]).first().model_id
add_item["field"] = add_item["field"]["id"]
ins = ModelSetting.objects.get(pk=add_item["id"])
get_serializers = build_serializers(ModelSetting.__name__, ModelSetting, {}, False)
serializers = get_serializers(ins, data=add_item, partial=True)
if serializers.is_valid():
serializers.save()
if model_id is None:
return Response({"msg": "没有获取到model_id"})
else:
Model.objects.get(pk=model_id).get_django_model()
return Response({"msg": "success"})
class CreateModel(APIView):
def post(self, request):
model_ins = Model.objects.create(**request.data)
model_ins.get_django_model()
return Response({
"msg": "success",
"model": request.data
})
class GetAppList(APIView):
def get(self, request):
data_ins = App.objects.all()
get_serializers = build_serializers(App.__name__, App, {}, False)
serializers = get_serializers(data_ins, many=True).data
return Response({
"msg": "success",
"data": serializers
})
class UseAPI(APIView):
# permission_classes = [NormalPermissionCheck]
def post(self, request):
# TODO 提取数据库部分进入依赖类、加入元数据元对象,元数据元对象逻辑优化
instance_in = Model.objects.all()
get_serializers = build_serializers(Model.__name__, Model, {}, False)
datas = get_serializers(instance_in, many=True).data
# get api信息
model_instance = get_model(request.data['model'])
model_instance_info = get_model_status(request.data['model'])
get_serializers = build_serializers(model_instance._meta.model_name, model_instance, {}, False)
self.check_object_permissions(self.request, model_instance_info)
data = get_serializers(model_instance.objects.get(api_name_en=request.data['api_name'])).data
with open(os.path.join(BASE_DIR, "api_django.json")) as f:
port = json.load(f)["port"]
# 请求api
if request.content_type.startswith('multipart/form-data'):
zip_file = request.FILES['zip']
files = {
'zip': (zip_file.name, zip_file, 'application/zip') # 关键修正!
}
post_data = {
"api_info": json.dumps(data),
}
del request.data["model"]
del request.data["zip"]
for k, v in request.data.items():
post_data[k] = v
res = requests.post(f'http://127.0.0.1:{port}/ApiClass/base_api_control/api_url/', files=files,
data=post_data)
else:
headers = {'Content-Type': 'application/json'}
post_data = {
"api_info": data,
"process_data": request.data["process_data"],
}
post_data = json.dumps(post_data)
res = requests.post(f'http://127.0.0.1:{port}/ApiClass/base_api_control/api_url/', data=post_data,
headers=headers)
"""
对于api返回的信息做出以下规定
1 data -- 直接显示返回
2 add_data -- 传入对应的model内中进行添加或者修改
3 search_data -- 查询对应的表
"""
return_data = copy.deepcopy(res.json())
if 'add_data' in return_data:
# 添加结束后删除
for add_item in return_data['add_data']:
if add_item['model'] == "permission":
for add_p in add_item['data']:
serializer = PermissionsSerializer(data=add_p)
if serializer.is_valid(raise_exception=True):
serializer.save()
else:
reverse_add_sub_data(add_item["data"], sub_model_instance=get_model(add_item['model']))
del return_data['add_data']
return Response(return_data)
class RelatedRecord(APIView):
def post(self, request):
model_name = request.data["model"]["name"]
ser = []
for items in get_model(model_name)._meta.get_fields():
if items.name == request.data["name"]:
model_ins = items.remote_field.model
target_data = model_ins.objects.all()
serializers_re = build_serializers(model_ins._meta.model_name,
model_ins, {},
False)
ser = serializers_re(target_data, many=True).data
return Response({"msg": "success", "data": ser})
class RecordOperate(APIView):
def get(self, request):
return_data = {}
active_related = False
return_data_columns = []
for search_item in request.GET.getlist('search_data[]'):
if "related" in json.loads(search_item)["Q"]:
active_related = True
search_item_model_instance = get_model(json.loads(search_item)['model'])
search_item_get_serializers = build_serializers(search_item_model_instance._meta.model_name,
search_item_model_instance, {},
active_related)
return_data_columns = get_model_fields(json.loads(search_item)['model'])
if json.loads(search_item)["Q"] == {}:
target_data = search_item_model_instance.objects.all()
datas = search_item_get_serializers(target_data, many=True).data
return_data = datas
else:
filter_data = copy.deepcopy(json.loads(search_item)["Q"])
if filter_data["Q_obj"] != "":
filter_data["Q_obj"] = eval(filter_data["Q_obj"])
else:
del filter_data["Q_obj"]
if 'id' in filter_data:
target_data = search_item_model_instance.objects.get(id=filter_data["id"])
datas = search_item_get_serializers(target_data).data
elif 'uuid' in filter_data:
target_data = search_item_model_instance.objects.get(uuid=filter_data["uuid"])
datas = search_item_get_serializers(target_data).data
else:
target_data = search_item_model_instance.objects.filter(**filter_data)
datas = search_item_get_serializers(target_data, many=True).data
return_data = datas
return Response({"msg": "success", "data": {
"return_data": return_data,
"return_data_columns": return_data_columns
}})
def post(self, request):
reverse_add_sub_data(request.data['add_data'])
return Response({"msg": "success", "data": {}})
def put(self, request):
pass
def delete(self, request):
search_item_model_instance = get_model(request.data['model'])
filter_data = copy.deepcopy(request.data['Q'])
if 'id' in filter_data:
search_item_model_instance.objects.get(id=filter_data["id"]).delete()
elif 'uuid' in filter_data:
search_item_model_instance.objects.get(uuid=filter_data["uuid"]).delete()
return Response({"msg": "success", "data": "删除成功"})
blacklist_ips = {
}
class Blacklist(APIView):
def get(self, request):
# SQL 注入检测规则
# 放行请求
response = JsonResponse({"status": "allowed"})
response['apache-status'] = 'allowed'
return response