|
|
import json
|
|
|
import logging
|
|
|
import random
|
|
|
|
|
|
from django.db.models import Count, F, Sum
|
|
|
from django.db.models.functions import ExtractMonth
|
|
|
from rest_framework.response import Response
|
|
|
from rest_framework.viewsets import ModelViewSet
|
|
|
|
|
|
from app import shortuuid, consts
|
|
|
from app.pagination import MyPageNumberPagination
|
|
|
from app.serializers import ServerSerializer, AlgModelSerializer, EnterpriseSerializer, EnterpriseDeviceSerializer, \
|
|
|
DeviceClassificationSerializer, WarningStatisticsSerializer, EnterpriseNodeSerializer, ComputeConfigSerializer, \
|
|
|
ModelVersionSerializer, EnterpriseAlertDeviceSerializer, ModelHubSerializer, EnterpriseBusiModelSerializer, \
|
|
|
EnterpriseBusiModelNodeSerializer, EnterpriseBusiModelNodeDeviceSerializer, ServerLogSerializer, \
|
|
|
ModelClassificationSerializer, FilesSerializer, MessageSerializer, WorkshopSerializer, WorkshopDeviceSerializer
|
|
|
from app.models import ServerModel, AlgModelModel, EnterpriseModel, EnterpriseDeviceModel, DeviceClassificationModel, \
|
|
|
WarningStatisticsModel, EnterpriseNodeModel, ComputeConfigModel, ModelVersionModel, EnterpriseAlertDeviceModel, \
|
|
|
ModelHubModel, EnterpriseBusiModelModel, EnterpriseBusiModelNodeModel, EnterpriseBusiModelNodeDeviceModel, \
|
|
|
ServerLogModel, ModelClassificationModel, FilesModel, MessageModel, WorkshopModel, WorkshopDeviceModel
|
|
|
|
|
|
logger = logging.getLogger('mylogger')
|
|
|
|
|
|
|
|
|
# Create your views here.
|
|
|
|
|
|
|
|
|
class EnterpriseModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = EnterpriseModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = EnterpriseSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
industry = data.get("industry")
|
|
|
|
|
|
# 新增
|
|
|
if not obj_id:
|
|
|
if not industry:
|
|
|
return Response({"msg": "缺少行业类型", "status": 400, "success": False, "data": None})
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
if industry and industry not in consts.industry_map:
|
|
|
return Response({"msg": "行业类型错误", "status": 400, "success": False, "data": None})
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询企业对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
|
|
|
if not obj_id:
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class EnterpriseAlertModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = EnterpriseAlertDeviceModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = EnterpriseAlertDeviceSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
node_id = data.get("node_id")
|
|
|
node_suid = data.get("node_suid") # 新增
|
|
|
if not (obj_id or node_suid or node_id):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
elif node_suid:
|
|
|
instance = self.queryset.filter(node_suid=node_suid).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(node_id=node_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
enterprise_suid = data.get("enterprise_suid")
|
|
|
node_id = data.get("node_id")
|
|
|
node_suid = data.get("node_suid")
|
|
|
|
|
|
status = data.get("status")
|
|
|
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if enterprise_suid:
|
|
|
self.queryset = self.queryset.filter(enterprise_suid=enterprise_suid)
|
|
|
|
|
|
if not (obj_id or node_id or node_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
elif node_suid:
|
|
|
instance = self.queryset.filter(node_suid=node_suid).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(node_id=node_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class ServerModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = ServerModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = ServerSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
# 新增
|
|
|
if not obj_id:
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询设备对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
status = data.get("status")
|
|
|
|
|
|
online_count = 0
|
|
|
offline_count = 0
|
|
|
all_count_res = self.queryset.values("status").annotate(count=Count("id")).order_by("status")
|
|
|
for i in all_count_res:
|
|
|
if i["status"] == 1001:
|
|
|
online_count = i["count"]
|
|
|
else:
|
|
|
offline_count = i["count"]
|
|
|
|
|
|
all_count = online_count + offline_count
|
|
|
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if not obj_id:
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"all_count": all_count,
|
|
|
"online_count": online_count,
|
|
|
"offline_count": offline_count,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询服务器对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class ServerLogModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = ServerLogModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = ServerLogSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
# 新增
|
|
|
if not obj_id:
|
|
|
# 服务器id不存在时，查询后添加
|
|
|
if not data.get("server_id"):
|
|
|
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
|
|
|
if x_forwarded_for:
|
|
|
server_ip = x_forwarded_for.split(',')[0]
|
|
|
else:
|
|
|
server_ip = request.META.get('REMOTE_ADDR')
|
|
|
|
|
|
server_obj = ServerModel.objects.filter(server_ip=server_ip).last()
|
|
|
if server_obj:
|
|
|
data["server_id"] = server_obj.id
|
|
|
else:
|
|
|
return Response({"msg": "该服务器不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(data=data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
server_id = data.get("server_id")
|
|
|
|
|
|
if server_id:
|
|
|
self.queryset = self.queryset.filter(server_id=server_id)
|
|
|
|
|
|
if not obj_id:
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询服务器对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class AlgModelModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = AlgModelModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = AlgModelSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
# 新增
|
|
|
if not obj_id:
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询设备对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
classification = data.get("classification")
|
|
|
model_type = data.get("model_type")
|
|
|
provider = data.get("provider")
|
|
|
default_version = data.get("default_version")
|
|
|
status = data.get("status")
|
|
|
|
|
|
if classification:
|
|
|
self.queryset = self.queryset.filter(classification=classification)
|
|
|
if model_type:
|
|
|
self.queryset = self.queryset.filter(model_type=model_type)
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
if provider:
|
|
|
self.queryset = self.queryset.filter(provider=provider)
|
|
|
if default_version:
|
|
|
self.queryset = self.queryset.filter(default_version=default_version)
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询模型对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class ModelClassificationModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = ModelClassificationModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = ModelClassificationSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
# status = data.get("status")
|
|
|
#
|
|
|
# if status:
|
|
|
# self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class ModelVersionModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = ModelVersionModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = ModelVersionSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
model_id = data.get("model_id")
|
|
|
status = data.get("status")
|
|
|
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
if model_id:
|
|
|
self.queryset = self.queryset.filter(model_id=model_id)
|
|
|
|
|
|
if not obj_id:
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def set_default_version(self, request, *args, **kwargs):
|
|
|
version_id = request.data.get("version_id")
|
|
|
model_id = request.data.get("model_id")
|
|
|
if not version_id or not model_id:
|
|
|
return Response({"msg": "参数缺失", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
ModelVersionModel.objects.filter(model_id=model_id).update(is_default=0)
|
|
|
ModelVersionModel.objects.filter(id=version_id).update(is_default=1)
|
|
|
return Response({
|
|
|
"data": None,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class ModelHubModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = ModelHubModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = ModelHubSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class EnterpriseDeviceModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = EnterpriseDeviceModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = EnterpriseDeviceSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询设备对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
classification = data.get("classification")
|
|
|
entity_id = data.get("entity_id")
|
|
|
entity_suid = data.get("entity_suid")
|
|
|
node_id = data.get("node_id")
|
|
|
node_suid = data.get("node_suid")
|
|
|
status = data.get("status")
|
|
|
is_used = data.get("is_used")
|
|
|
|
|
|
if classification:
|
|
|
self.queryset = self.queryset.filter(classification=classification)
|
|
|
if entity_id:
|
|
|
self.queryset = self.queryset.filter(entity_id=entity_id)
|
|
|
if entity_suid:
|
|
|
self.queryset = self.queryset.filter(entity_suid=entity_suid)
|
|
|
if node_id:
|
|
|
self.queryset = self.queryset.filter(node_id=node_id)
|
|
|
if node_suid:
|
|
|
self.queryset = self.queryset.filter(node_suid=node_suid)
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
if is_used:
|
|
|
self.queryset = self.queryset.filter(is_used=is_used)
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询服务器对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class DeviceClassificationModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = DeviceClassificationModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = DeviceClassificationSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
name = data.get("name")
|
|
|
|
|
|
if name:
|
|
|
self.queryset = self.queryset.filter(name=name)
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class WarningStatisticsModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = WarningStatisticsModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = WarningStatisticsSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
warning_level = data.get("warning_level")
|
|
|
warning_name = data.get("warning_name")
|
|
|
server_id = data.get("server_id")
|
|
|
server_suid = data.get("server_suid")
|
|
|
node_id = data.get("node_id")
|
|
|
node_suid = data.get("node_suid")
|
|
|
device_id = data.get("device_id")
|
|
|
device_suid = data.get("device_suid")
|
|
|
warning_type = data.get("warning_type")
|
|
|
start_trigger_time = data.get("start_time")
|
|
|
end_trigger_time = data.get("end_time")
|
|
|
|
|
|
if warning_level:
|
|
|
self.queryset = self.queryset.filter(warning_level=warning_level)
|
|
|
|
|
|
if warning_name:
|
|
|
self.queryset = self.queryset.filter(warning_name=warning_name)
|
|
|
|
|
|
if server_id:
|
|
|
self.queryset = self.queryset.filter(server_id=server_id)
|
|
|
|
|
|
if server_suid:
|
|
|
self.queryset = self.queryset.filter(server_suid=server_suid)
|
|
|
|
|
|
if node_id:
|
|
|
self.queryset = self.queryset.filter(node_id=node_id)
|
|
|
|
|
|
if node_suid:
|
|
|
self.queryset = self.queryset.filter(node_suid=node_suid)
|
|
|
|
|
|
if device_id:
|
|
|
self.queryset = self.queryset.filter(device_id=device_id)
|
|
|
|
|
|
if device_suid:
|
|
|
self.queryset = self.queryset.filter(device_suid=device_suid)
|
|
|
|
|
|
if warning_type:
|
|
|
self.queryset = self.queryset.filter(warning_type=warning_type)
|
|
|
|
|
|
if start_trigger_time:
|
|
|
self.queryset = self.queryset.filter(trigger_time__in=[start_trigger_time, end_trigger_time])
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def get_warning_names(self, request, *args, **kwargs):
|
|
|
warning_names = self.queryset.values("warning_name").distinct()
|
|
|
|
|
|
return Response({
|
|
|
"data": [tmp.get("warning_name") for tmp in warning_names],
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class EnterpriseNodeModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = EnterpriseNodeModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = EnterpriseNodeSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
entity_suid = data.get("entity_suid")
|
|
|
name = data.get("name")
|
|
|
parent = data.get("parent")
|
|
|
status = data.get("status")
|
|
|
|
|
|
children = data.get("children")
|
|
|
|
|
|
if entity_suid:
|
|
|
self.queryset = self.queryset.filter(entity_suid=entity_suid)
|
|
|
|
|
|
if name:
|
|
|
self.queryset = self.queryset.filter(name=name)
|
|
|
|
|
|
if parent:
|
|
|
self.queryset = self.queryset.filter(parent=parent)
|
|
|
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if children and not obj_id:
|
|
|
self.queryset = self.queryset.filter(parent=None)
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
queryset = self.filter_queryset(self.get_queryset())
|
|
|
|
|
|
page = self.paginate_queryset(queryset)
|
|
|
if page is not None:
|
|
|
serializer = self.get_serializer(page, many=True)
|
|
|
else:
|
|
|
|
|
|
serializer = self.get_serializer(queryset, many=True)
|
|
|
|
|
|
return Response({
|
|
|
"data": serializer.data_with_children if children else serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data_with_children if children else serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class EnterpriseBusiModelModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = EnterpriseBusiModelModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = EnterpriseBusiModelSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
model_node_data = {
|
|
|
"entity_id": data.get("entity_id"),
|
|
|
"busimodel_id": None,
|
|
|
"busimodel_suid": None,
|
|
|
"node_ids": data.get("link_node_ids")
|
|
|
}
|
|
|
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
|
|
|
model_node_data["busimodel_id"] = serializer.data.get("id")
|
|
|
model_node_data["busimodel_suid"] = serializer.data.get("suid")
|
|
|
self.insert_model_node(model_node_data)
|
|
|
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
# 删除前判断是否关联设备，否则删除相关节点
|
|
|
if data.get("status"):
|
|
|
flag = EnterpriseBusiModelNodeDeviceModel.objects.filter(busi_model_id=obj_id).all()
|
|
|
if flag:
|
|
|
return Response(
|
|
|
{"msg": "该业务模型已关联设备，无法删除", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.data, partial=partial)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_update(serializer)
|
|
|
|
|
|
if getattr(instance, '_prefetched_objects_cache', None):
|
|
|
instance._prefetched_objects_cache = {}
|
|
|
|
|
|
model_node_data["busimodel_id"] = serializer.data.get("id")
|
|
|
model_node_data["busimodel_suid"] = serializer.data.get("suid")
|
|
|
self.insert_model_node(model_node_data, "update")
|
|
|
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def insert_model_node(self, data, mode="create"):
|
|
|
# 删除关联节点
|
|
|
if mode == "update":
|
|
|
EnterpriseBusiModelNodeModel.objects.filter(busi_model_id=data.get("busimodel_id")).all().delete()
|
|
|
|
|
|
link_node_ids = [int(node_id) for node_id in data['node_ids'].split(',')]
|
|
|
|
|
|
model_node_data_list = []
|
|
|
for node_id in link_node_ids:
|
|
|
logging.info("node_id: %s")
|
|
|
node_obj = EnterpriseNodeModel.objects.filter(id=node_id).get()
|
|
|
|
|
|
node_suid = node_obj.suid
|
|
|
entity_suid = node_obj.entity_suid
|
|
|
model_node_data = {
|
|
|
"suid": shortuuid.ShortUUID().random(10),
|
|
|
"entity_suid": entity_suid,
|
|
|
"busi_model_id": data['busimodel_id'],
|
|
|
"busi_model_suid": data['busimodel_suid'],
|
|
|
"node_id": node_id,
|
|
|
"node_suid": node_suid,
|
|
|
}
|
|
|
|
|
|
model_node_data_list.append(model_node_data)
|
|
|
|
|
|
if model_node_data_list:
|
|
|
serializer = EnterpriseBusiModelNodeSerializer(data=model_node_data_list, many=True)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
serializer.save()
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
entity_suid = data.get("entity_suid")
|
|
|
name = data.get("name")
|
|
|
status = data.get("status")
|
|
|
|
|
|
if entity_suid:
|
|
|
self.queryset = self.queryset.filter(entity_suid=entity_suid)
|
|
|
if name:
|
|
|
self.queryset = self.queryset.filter(name=name)
|
|
|
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if not (obj_id or obj_suid):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class EnterpriseBusiModelNodeDeviceModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = EnterpriseBusiModelNodeDeviceModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = EnterpriseBusiModelNodeDeviceSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
node_id = data.get("node_id")
|
|
|
busi_model_id = data.get("busi_model_id")
|
|
|
device_ids = data.get("device_ids", "")
|
|
|
|
|
|
if not (node_id and busi_model_id):
|
|
|
return Response({"msg": "参数错误", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
if not device_ids:
|
|
|
return Response({"msg": "设备不能为空", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
# serializer = self.get_serializer(data=request.data)
|
|
|
# serializer.is_valid(raise_exception=True)
|
|
|
# self.perform_create(serializer)
|
|
|
|
|
|
flag, serializer = self.insert_model_node_device(node_id, busi_model_id, device_ids)
|
|
|
|
|
|
if not flag:
|
|
|
return Response({"msg": serializer, "status": 400, "success": False, "data": None})
|
|
|
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def deal_with_compute(self, node_id, busi_model_id):
|
|
|
all_compute_objs = ComputeConfigModel.objects.all()
|
|
|
percentage = 0
|
|
|
for i in all_compute_objs:
|
|
|
percentage += i.percentage
|
|
|
|
|
|
if percentage < 0.5:
|
|
|
data = {
|
|
|
"node_id": node_id,
|
|
|
"model_id": busi_model_id,
|
|
|
"percentage": 0.1,
|
|
|
"efficiency": "20帧/秒"
|
|
|
}
|
|
|
else:
|
|
|
data = {
|
|
|
"node_id": node_id,
|
|
|
"model_id": busi_model_id,
|
|
|
"percentage": (1 - percentage) * 0.5,
|
|
|
"efficiency": "20帧/秒"
|
|
|
}
|
|
|
ComputeConfigModel.objects.create(**data)
|
|
|
|
|
|
def insert_model_node_device(self, node_id, busi_model_id, device_ids, mode="create"):
|
|
|
|
|
|
if mode == "update":
|
|
|
EnterpriseBusiModelNodeDeviceModel.objects.filter(node_id=node_id,
|
|
|
busi_model_id=busi_model_id).all().delete()
|
|
|
ComputeConfigModel.objects.filter(node_id=node_id, model_id=busi_model_id).all().delete()
|
|
|
|
|
|
# node = EnterpriseNodeModel.objects.filter(id=node_id).last()
|
|
|
#
|
|
|
# if not node:
|
|
|
# return False, "节点不存在"
|
|
|
|
|
|
entity_suid_row = EnterpriseNodeModel.objects.filter(id=node_id).last()
|
|
|
if not entity_suid_row:
|
|
|
return False, "节点不存在"
|
|
|
|
|
|
node_suid = entity_suid_row.suid
|
|
|
|
|
|
busi_model = EnterpriseBusiModelModel.objects.filter(id=busi_model_id).last()
|
|
|
if not busi_model:
|
|
|
return False, "企业模型不存在"
|
|
|
|
|
|
busi_model_suid = busi_model.suid
|
|
|
|
|
|
records = []
|
|
|
for device_id in device_ids.split(","):
|
|
|
device = EnterpriseDeviceModel.objects.filter(id=int(device_id)).last()
|
|
|
if not device:
|
|
|
return False, f"设备{device_id}不存在"
|
|
|
|
|
|
records.append(
|
|
|
{
|
|
|
"suid": shortuuid.ShortUUID().random(length=10),
|
|
|
"entity_suid": entity_suid_row.entity_suid,
|
|
|
"node_id": node_id,
|
|
|
"node_suid": node_suid,
|
|
|
"busi_model_id": busi_model_id,
|
|
|
"busi_model_suid": busi_model_suid,
|
|
|
"device_id": int(device_id),
|
|
|
"device_suid": device.suid,
|
|
|
}
|
|
|
)
|
|
|
|
|
|
serializer = EnterpriseBusiModelNodeDeviceSerializer(data=records, many=True)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
serializer.save()
|
|
|
|
|
|
self.deal_with_compute(node_id, busi_model_id)
|
|
|
|
|
|
return True, serializer
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
|
|
|
node_id = data.get("node_id")
|
|
|
busi_model_id = data.get("busi_model_id")
|
|
|
|
|
|
if not (obj_id or obj_suid or node_id or busi_model_id):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
|
|
|
if not node_id or not busi_model_id:
|
|
|
return Response({"msg": "参数错误", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
busi_model = EnterpriseBusiModelModel.objects.filter(id=busi_model_id).last()
|
|
|
if not busi_model:
|
|
|
return Response({"msg": "企业模型不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
busi_model_name = busi_model.name
|
|
|
busi_model_comment = busi_model.comment
|
|
|
base_models = json.loads(busi_model.base_models)
|
|
|
base_model_names = ",".join([base_model["name"] for base_model in base_models])
|
|
|
|
|
|
device_ids = self.queryset.filter(node_id=node_id, busi_model_id=busi_model_id).all().values("device_id")
|
|
|
device_ids = list(set([item["device_id"] for item in device_ids]))
|
|
|
devices = EnterpriseDeviceModel.objects.filter(id__in=device_ids, status=0).all()
|
|
|
|
|
|
devices_return = [
|
|
|
{"device_id": item.id, "device_name": item.name} for item in devices
|
|
|
]
|
|
|
|
|
|
return Response({
|
|
|
"data": {
|
|
|
"busi_model_name": busi_model_name,
|
|
|
"busi_model_comment": busi_model_comment,
|
|
|
"base_models": base_model_names,
|
|
|
"devices": devices_return,
|
|
|
},
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class ComputeConfigModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = ComputeConfigModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = ComputeConfigSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
obj_suid = data.get("suid")
|
|
|
# 新增
|
|
|
if not (obj_id or obj_suid):
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
# 更新
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(suid=obj_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
|
|
|
flag = data.get("flag", True)
|
|
|
|
|
|
if flag:
|
|
|
data = [
|
|
|
{
|
|
|
"type": 1,
|
|
|
"proportion": 7,
|
|
|
"pretreatmentEfficiency": 20,
|
|
|
"color": "#014BE6",
|
|
|
"bgColor": "linear-gradient(180deg, #015DE6 0%, #4881F6 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 2,
|
|
|
"proportion": 8,
|
|
|
"pretreatmentEfficiency": 20,
|
|
|
"color": "#FAA90B",
|
|
|
"bgColor": "linear-gradient(180deg, #E64601 0%, #F6A648 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 3,
|
|
|
"proportion": 4,
|
|
|
"pretreatmentEfficiency": 15,
|
|
|
"color": "#EA1281",
|
|
|
"bgColor": "linear-gradient(180deg, #E60161 0%, #F648E5 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 4,
|
|
|
"proportion": 7,
|
|
|
"pretreatmentEfficiency": 20,
|
|
|
"color": "#FA8616",
|
|
|
"bgColor": "linear-gradient(180deg, #FA8316 0%, #FAAD16 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 5,
|
|
|
"proportion": 32,
|
|
|
"pretreatmentEfficiency": 38,
|
|
|
"color": "#F9DB18",
|
|
|
"bgColor": "linear-gradient(180deg, #FFC56F 0%, #F9E006 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 6,
|
|
|
"proportion": 8,
|
|
|
"pretreatmentEfficiency": 38,
|
|
|
"color": "#1CCCFA",
|
|
|
"bgColor": "linear-gradient(180deg, #6FFFFF 0%, #06BEF9 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 7,
|
|
|
"proportion": 12,
|
|
|
"pretreatmentEfficiency": 38,
|
|
|
"color": "#9E26EE",
|
|
|
"bgColor": "linear-gradient(180deg, #FF2494 0%, #8D27FF 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 8,
|
|
|
"proportion": 7,
|
|
|
"pretreatmentEfficiency": 38,
|
|
|
"color": "#6F50F6",
|
|
|
"bgColor": "linear-gradient(180deg, #6B55F6 0%, #8C38F8 100%)"
|
|
|
},
|
|
|
{
|
|
|
"type": 9,
|
|
|
"proportion": 5,
|
|
|
"pretreatmentEfficiency": 38,
|
|
|
"color": "#24ED75",
|
|
|
"bgColor": "linear-gradient(180deg, #43EA80 0%, #38F8D4 100%)"
|
|
|
}
|
|
|
]
|
|
|
|
|
|
results = []
|
|
|
all_data = super().list(request, *args, **kwargs).data.get("results")
|
|
|
|
|
|
total_per = 0
|
|
|
for l, single in enumerate(all_data):
|
|
|
total_per += float(single.get("percentage").strip("%"))
|
|
|
|
|
|
tmp = data[(l + 1) % 9]
|
|
|
tmp["name"] = single.get("name")
|
|
|
tmp["proportion"] = eval(single.get("percentage").strip("%"))
|
|
|
tmp["pretreatmentEfficiency"] = single.get("efficiency")
|
|
|
results.append(
|
|
|
tmp
|
|
|
)
|
|
|
|
|
|
results.append(
|
|
|
{
|
|
|
"name": "空闲算力",
|
|
|
"type": 0,
|
|
|
"proportion": (100 - total_per) if (100 - total_per) > 0 else 0,
|
|
|
"pretreatmentEfficiency": 0,
|
|
|
"color": "#DCDCDC",
|
|
|
"bgColor": "linear-gradient(90deg, #7B7979 0%, #C1C1C1 100%)"
|
|
|
}
|
|
|
)
|
|
|
|
|
|
return Response({
|
|
|
"data": results,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
obj_id = data.get("id")
|
|
|
|
|
|
status = data.get("status")
|
|
|
|
|
|
server_id = data.get("server_id")
|
|
|
server_suid = data.get("server_suid")
|
|
|
node_id = data.get("node_id")
|
|
|
node_suid = data.get("node_suid")
|
|
|
device_id = data.get("device_id")
|
|
|
device_suid = data.get("device_suid")
|
|
|
model_id = data.get("model_id")
|
|
|
model_suid = data.get("model_suid")
|
|
|
|
|
|
if server_id:
|
|
|
self.queryset = self.queryset.filter(server_id=server_id)
|
|
|
|
|
|
if server_suid:
|
|
|
self.queryset = self.queryset.filter(server_suid=server_suid)
|
|
|
|
|
|
if node_id:
|
|
|
self.queryset = self.queryset.filter(node_id=node_id)
|
|
|
|
|
|
if node_suid:
|
|
|
self.queryset = self.queryset.filter(node_suid=node_suid)
|
|
|
|
|
|
if device_id:
|
|
|
self.queryset = self.queryset.filter(device_id=device_id)
|
|
|
|
|
|
if device_suid:
|
|
|
self.queryset = self.queryset.filter(device_suid=device_suid)
|
|
|
|
|
|
if model_id:
|
|
|
self.queryset = self.queryset.filter(model_id=model_id)
|
|
|
|
|
|
if model_suid:
|
|
|
self.queryset = self.queryset.filter(model_suid=model_suid)
|
|
|
|
|
|
if status:
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if not (obj_id or model_suid or model_id):
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
elif model_id:
|
|
|
instance = self.queryset.filter(model_id=model_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(model_suid=model_suid).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class FilesModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = FilesModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = FilesSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
if not obj_id:
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
# return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
md5_str = data.get("md5_str")
|
|
|
|
|
|
if not obj_id or not md5_str:
|
|
|
# return super().list(request, *args, **kwargs)
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
else:
|
|
|
try:
|
|
|
if obj_id:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
else:
|
|
|
instance = self.queryset.filter(md5_str=md5_str).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def destroy(self, request, *args, **kwargs):
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
self.perform_destroy(instance)
|
|
|
return Response({"msg": "对象已删除", "status": 200, "success": True, "data": None})
|
|
|
|
|
|
|
|
|
class MessageModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = MessageModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = MessageSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
if not obj_id:
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
# return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
is_checked = data.get("is_checked", "all")
|
|
|
|
|
|
if is_checked is not "all":
|
|
|
self.queryset = self.queryset.filter(is_checked=is_checked)
|
|
|
|
|
|
if not obj_id:
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
else:
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class DataOverviewModelViewSet(ModelViewSet):
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
|
|
|
total_warning = WarningStatisticsModel.objects.count()
|
|
|
total_device = EnterpriseDeviceModel.objects.count()
|
|
|
total_node = EnterpriseNodeModel.objects.count()
|
|
|
|
|
|
data = {
|
|
|
"total_warning": total_warning if total_warning else 0,
|
|
|
"total_device": total_device if total_device else 0,
|
|
|
"total_node": total_node if total_node else 0,
|
|
|
"total_resource": f"{random.uniform(0.3, 0.8) * 100:.3f}%"
|
|
|
}
|
|
|
|
|
|
return Response({
|
|
|
"data": data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class DeviceAndWarningsModelViewSet(ModelViewSet):
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
device_status_dic = {
|
|
|
"onlineCount": 0,
|
|
|
"errorCount": 0,
|
|
|
"processCount": 0,
|
|
|
"outlineCount": 0
|
|
|
}
|
|
|
device_status_list = EnterpriseDeviceModel.objects.values("status").annotate(count=Count("id")).order_by("status")
|
|
|
|
|
|
for i in device_status_list:
|
|
|
if i["status"] == 1001:
|
|
|
device_status_dic["onlineCount"] = i["count"]
|
|
|
elif i["status"] == 1002:
|
|
|
device_status_dic["outlineCount"] = i["count"]
|
|
|
elif i["status"] == 1003:
|
|
|
device_status_dic["errorCount"] = i["count"]
|
|
|
|
|
|
running_count = EnterpriseBusiModelNodeDeviceModel.objects.values("device_id").annotate(count=Count("id")).order_by("device_id")
|
|
|
device_status_dic["processCount"] = len(running_count)
|
|
|
|
|
|
device_warnings_list = list()
|
|
|
# device_warnings = WarningStatisticsModel.objects.values("warning_level").annotate(value=Count("id"), name=F("warning_level")).order_by("value")
|
|
|
dic = {
|
|
|
"1": "紧急",
|
|
|
"2": "较高",
|
|
|
"3": "一般",
|
|
|
"4": "低",
|
|
|
"5": "较低",
|
|
|
"6": "非常低",
|
|
|
}
|
|
|
device_warnings = WarningStatisticsModel.objects.values("warning_level").annotate(value=Count("id")).order_by("value")
|
|
|
for dw in device_warnings:
|
|
|
dw["name"] = dic.get(dw["warning_level"])
|
|
|
device_warnings_list.append(dw)
|
|
|
|
|
|
compute_used = ComputeConfigModel.objects.values("percentage").aggregate(value=Sum("percentage")).get("value", 0)
|
|
|
|
|
|
compute_used_info = [
|
|
|
{"value": (1 - compute_used) * 100, "name": "未占用"},
|
|
|
{"value": compute_used * 100, "name": "已占用"}
|
|
|
]
|
|
|
|
|
|
data = {
|
|
|
"device_status": device_status_dic,
|
|
|
"device_warnings": device_warnings_list,
|
|
|
"compute_used": compute_used_info
|
|
|
}
|
|
|
|
|
|
return Response({
|
|
|
"data": data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class WarningsAndMessageModelViewSet(ModelViewSet):
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
warnings_list = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
|
|
|
warnings_values = WarningStatisticsModel.objects.annotate(month=ExtractMonth('trigger_time')).values("month").annotate(count=Count("id"))
|
|
|
|
|
|
for warnings in warnings_values:
|
|
|
warnings_list[warnings["month"] - 1] = warnings["count"]
|
|
|
|
|
|
message_dic = {
|
|
|
"checked": 0,
|
|
|
"unchecked": 0
|
|
|
}
|
|
|
message_amount = MessageModel.objects.values("is_checked").annotate(count=Count("id"))
|
|
|
|
|
|
for message in message_amount:
|
|
|
if message["is_checked"] == 0:
|
|
|
message_dic["unchecked"] = message["count"]
|
|
|
else:
|
|
|
message_dic["checked"] = message["count"]
|
|
|
|
|
|
data = {
|
|
|
"warnings_list": warnings_list,
|
|
|
"message": message_dic
|
|
|
}
|
|
|
|
|
|
return Response({
|
|
|
"data": data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class ClassifyWarningsModelViewSet(ModelViewSet):
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
# 缺陷总数折线图
|
|
|
defectData = [46, 460, 100, 300, 20]
|
|
|
|
|
|
# 告警分类折线图
|
|
|
alarmData = {
|
|
|
"thread": [246, 246, 246, 180, 160],
|
|
|
"PIN": [160, 246, 450, 100, 246],
|
|
|
"plate": [100, 200, 400, 150, 306],
|
|
|
"scratched": [10, 20, 400, 150, 206],
|
|
|
"workpieceSize": [150, 250, 500, 50, 36]
|
|
|
}
|
|
|
|
|
|
# 缺陷3D柱状图
|
|
|
defect3DData = [100, 500, 400, 600, 700, 200]
|
|
|
|
|
|
data = {
|
|
|
"defectData": defectData,
|
|
|
"alarmData": alarmData,
|
|
|
"defect3DData": defect3DData
|
|
|
}
|
|
|
|
|
|
return Response({
|
|
|
"data": data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class WorkshopModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = WorkshopModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = WorkshopSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
status = data.get("status", 0)
|
|
|
|
|
|
if status in (0, 1):
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if not obj_id:
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
else:
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
data = request.data
|
|
|
obj_id = data.get("id")
|
|
|
if not obj_id:
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
# return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.data, partial=partial)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_update(serializer)
|
|
|
if getattr(instance, '_prefetched_objects_cache', None):
|
|
|
instance._prefetched_objects_cache = {}
|
|
|
|
|
|
# 同步删除所有相关联记录
|
|
|
if data.get("status") in (1, "1"):
|
|
|
WorkshopDeviceModel.objects.filter(workshop_id=obj_id).all().update(status=1)
|
|
|
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
|
|
|
class WorkshopDeviceModelViewSet(ModelViewSet):
|
|
|
# 查询类
|
|
|
queryset = WorkshopDeviceModel.objects.all().order_by("id")
|
|
|
# 序列化类
|
|
|
serializer_class = WorkshopDeviceSerializer
|
|
|
# 分页类
|
|
|
pagination_class = MyPageNumberPagination
|
|
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
|
data = request.query_params
|
|
|
obj_id = data.get("id")
|
|
|
status = data.get("status", 0)
|
|
|
workshop_id = data.get("workshop_id")
|
|
|
|
|
|
if status in (0, 1):
|
|
|
self.queryset = self.queryset.filter(status=status)
|
|
|
|
|
|
if workshop_id:
|
|
|
self.queryset = self.queryset.filter(workshop_id=workshop_id)
|
|
|
|
|
|
if not obj_id:
|
|
|
return Response({
|
|
|
"data": super().list(request, *args, **kwargs).data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
else:
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
|
data = request.data
|
|
|
obj_id = data.get("id") or data.get("wd_id")
|
|
|
# 设备重复绑定
|
|
|
# device_id = data.get("device_id")
|
|
|
# workshop_id = data.get("workshop_id")
|
|
|
# exist_obj = self.queryset.filter(device_id=device_id).last()
|
|
|
# if exist_obj:
|
|
|
# if exist_obj.workshop_id == workshop_id:
|
|
|
# obj_id = obj_id if obj_id else exist_obj.id
|
|
|
|
|
|
if not obj_id:
|
|
|
# exist_id = data.get("wd_id")
|
|
|
# WorkshopDeviceModel.objects.filter(id=exist_id).update(status=1)
|
|
|
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
|
serializer.is_valid(raise_exception=True)
|
|
|
self.perform_create(serializer)
|
|
|
headers = self.get_success_headers(serializer.data)
|
|
|
return Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": "新增成功",
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
}, headers=headers)
|
|
|
else:
|
|
|
partial = kwargs.pop('partial', True)
|
|
|
try:
|
|
|
instance = self.queryset.filter(id=obj_id).get()
|
|
|
except Exception as e:
|
|
|
logger.error(f"查询对象报错:{e}")
|
|
|
return Response({"msg": "该对象不存在", "status": 400, "success": False, "data": None})
|
|
|
|
|
|
serializer = self.get_serializer(instance, data=request.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 Response({
|
|
|
"data": serializer.data,
|
|
|
"msg": "编辑成功",
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def destroy(self, request, *args, **kwargs):
|
|
|
|
|
|
data = request.data
|
|
|
ids = data.get("ids")
|
|
|
self.queryset.filter(id__in=ids).all().update(status=1)
|
|
|
|
|
|
return Response({
|
|
|
"data": None,
|
|
|
"msg": "删除成功",
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|
|
|
def get_devices(self, request, *args, **kwargs):
|
|
|
|
|
|
device_ids_dict = dict()
|
|
|
# device_ids = self.queryset.filter(status=0).order_by("id").values("device_id", "id")
|
|
|
wd_objs = self.queryset.filter(status=0).order_by("id").all()
|
|
|
|
|
|
wd_objs_serializer = self.get_serializer(wd_objs, many=True)
|
|
|
|
|
|
for obj in wd_objs_serializer.data:
|
|
|
device_ids_dict[obj.get("device_id")] = obj
|
|
|
|
|
|
queryset = EnterpriseDeviceModel.objects.all()
|
|
|
serializer = EnterpriseDeviceSerializer(queryset, many=True)
|
|
|
|
|
|
res = []
|
|
|
|
|
|
for i in serializer.data:
|
|
|
if i.get("id") in device_ids_dict:
|
|
|
i["is_binding"] = True
|
|
|
i["wd_id"] = device_ids_dict[i.get("id")].get("id")
|
|
|
i["workshop_name"] = device_ids_dict[i.get("id")].get("workshop_name")
|
|
|
else:
|
|
|
i["is_binding"] = False
|
|
|
|
|
|
res.append(i)
|
|
|
|
|
|
return Response({
|
|
|
"data": res,
|
|
|
"msg": None,
|
|
|
"success": True,
|
|
|
"status": 200
|
|
|
})
|
|
|
|