Yaxin
/
General-Platform-Backend
forked from kongfp/General-Platform-Backend
31
0
Fork 0
Code Pull Requests Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
General-Platform-Backend/app/views.py

2311 lines
81 KiB
Python
Raw Permalink Normal View History Unescape Escape

fix bugs
7 months ago
import datetime
init project
9 months ago
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, \
add workshop and device
8 months ago
ModelClassificationSerializer, FilesSerializer, MessageSerializer, WorkshopSerializer, WorkshopDeviceSerializer
init project
9 months ago
from app.models import ServerModel, AlgModelModel, EnterpriseModel, EnterpriseDeviceModel, DeviceClassificationModel, \
WarningStatisticsModel, EnterpriseNodeModel, ComputeConfigModel, ModelVersionModel, EnterpriseAlertDeviceModel, \
ModelHubModel, EnterpriseBusiModelModel, EnterpriseBusiModelNodeModel, EnterpriseBusiModelNodeDeviceModel, \
add workshop and device
8 months ago
ServerLogModel, ModelClassificationModel, FilesModel, MessageModel, WorkshopModel, WorkshopDeviceModel
init project
9 months ago
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")
fix bugs
7 months ago
# end_trigger_time = data.get("end_time")
init project
9 months ago
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:
fix bugs
7 months ago
try:
start_datetime = datetime.datetime.strptime(start_trigger_time, "%Y-%m-%d")
except Exception as e:
logger.error(f"查询告警时间格式报错{e}，参数为:{start_trigger_time}")
return Response({"data": None, "msg": "时间格式不正确", "success": False, "status": 400})
end_datetime = start_datetime + datetime.timedelta(days=1)
self.queryset = self.queryset.filter(trigger_time__range=[start_datetime, end_datetime])
init project
9 months ago
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
})
fix bugs
7 months ago
def get_warning_names(self, request, *args, **kwargs):
fix bugs
7 months ago
warning_names = self.queryset.values_list("warning_name", flat=True).order_by("warning_name").distinct()
return Response({
"data": warning_names,
"msg": None,
"success": True,
"status": 200
})
def get_warning_types(self, request, *args, **kwargs):
warning_types = self.queryset.values_list('warning_type', flat=True).order_by("warning_type").distinct()
fix bugs
7 months ago
return Response({
fix bugs
7 months ago
"data": warning_types,
fix bugs
7 months ago
"msg": None,
"success": True,
"status": 200
})
init project
9 months ago
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
})
add workshop and device
8 months ago
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
})