def create(self, request, *args, **kwargs):
data = {}
data['os_name'] = request.data['os_name']
data['os_version'] = request.data['os_version']
data['comp_name'] = request.data['comp_name']
data['comp_version'] = request.data['comp_version']
username = request.data['machine_owner']
user = User.objects.filter(username=username).filter().first()
user_serializer = UserSerializer(user)
data['machine_owner'] = user_serializer.data['id']
serializer = MachineSerializer(data=data)
serializer.is_valid(raise_exception=True)
machine = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response('success',
status=status.HTTP_201_CREATED,
headers=headers)
def get_reports(self, obj):
"""
Number of reports
"""
machine_dict = []
target_machines = Machine.objects.filter(owner=obj.id)
serializer = MachineSerializer(target_machines, many=True)
# print(serializer.data)
for item in serializer.data:
machine_dict.append(item['sn'])
reports = TestRecord.objects.filter(
test_machine__sn__in=machine_dict).count()
return reports
def post(request):
serializer = MachineSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(request):
data = Machine.objects.all()
serializer = MachineSerializer(data, many=True)
return Response(serializer.data)
class TestRecordDetailSerializer(serializers.ModelSerializer):
'''
use ModelSerializer
'''
branch = serializers.SerializerMethodField()
date = serializers.SerializerMethodField()
pg_info = PGInfoSerializer()
linux_info = LinuxInfoDetailSerializer()
test_machine = MachineSerializer()
hardware_info = serializers.SerializerMethodField()
meta_info = MetaInfoDetailSerializer()
dataset_info = serializers.SerializerMethodField()
prev = serializers.SerializerMethodField()
class Meta:
model = TestRecord
fields = ('branch', 'date', 'uuid', 'pg_info', 'linux_info',
'hardware_info', 'meta_info', 'dataset_info', 'test_desc',
'meta_time', 'test_machine', 'commit', 'prev')
def get_prev(self, obj):
target = TestDataSet.objects.filter(test_record_id=obj.id).first()
serializer = TestDataSetDetailSerializer(target)
prev = serializer.data["prev"]
target = TestDataSet.objects.filter(id=prev).first()
serializer = TestDataSetDetailSerializer(target)
record_id = serializer.data["test_record"]
target_record = TestRecord.objects.filter(id=record_id).first()
serializer = TestRecordDetailSerializer(target_record)
return serializer.data["uuid"]
def get_branch(self, obj):
branch = TestBranch.objects.filter(id=obj.branch_id).first()
serializer = TestBranchSerializer(branch)
return serializer.data["branch_name"]
def get_date(self, obj):
target_meta_info = MetaInfo.objects.filter(id=obj.meta_info.id).first()
return target_meta_info.date
def get_hardware_info(self, obj):
target_data = LinuxInfo.objects.filter(id=obj.linux_info.id).first()
hardware_info_serializer = HardwareInfoDetailSerializer(target_data)
return hardware_info_serializer.data
def get_dataset_info(self, obj):
dataset_list = TestDataSet.objects.filter(
test_record_id=obj.id).values_list('test_cate_id').annotate(
Count('id'))
# print(dataset_list)
dataset = {}
# < QuerySet[(1, 3), (2, 3)] >
for cate_item in dataset_list:
cate_info = TestCategory.objects.filter(id=cate_item[0]).first()
cate_info_serializer = TestCategorySerializer(cate_info)
cate_sn = cate_info_serializer.data["cate_sn"]
dataset[cate_sn] = {}
dataset_scale_list = TestDataSet.objects.filter(
test_record_id=obj.id,
test_cate=cate_item[0]).values_list('scale').annotate(
Count('id'))
# print(dataset_scale_list) # <QuerySet [(10, 2), (20, 1)]>
for scale_item in dataset_scale_list:
dataset[cate_sn][scale_item[0]] = {}
dataset_client_list = TestDataSet.objects.filter(
test_record_id=obj.id,
test_cate=cate_item[0],
scale=scale_item[0]).values_list('clients').annotate(
Count('id'))
# print(dataset_client_list) # <QuerySet [(1, 1), (2, 1), (4, 1)]>
for client_item in dataset_client_list:
dataset[cate_sn][scale_item[0]][client_item[0]] = []
target_dataset = TestDataSet.objects.filter(
test_record_id=obj.id,
test_cate=cate_item[0],
scale=scale_item[0],
clients=client_item[0])
dataset_serializer = TestDataSetDetailSerializer(
target_dataset, many=True)
dataset[cate_sn][scale_item[0]][
client_item[0]] = dataset_serializer.data
return dataset
def get_machine_info(self, obj):
machine_data = Machine.objects.filter(id=obj.test_machine_id)
machine_info_serializer = MachineSerializer(machine_data, many=True)
return machine_info_serializer.data