def post(self, request, project): serializer = AppAttrSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) # if not check_name(AppAttr, serializer.data['name'], project): # return Response({'detail': unicode("Found same name attr, " # "please check your attr name.")}, # status=status.HTTP_409_CONFLICT) if AppAttr.objects.filter(name=serializer.validated_data['name'], app=serializer.validated_data['app'], project=get_project_object(project)).count(): return Response( { 'detail': unicode("Found same name attr, " "please check your attr name.") }, status=status.HTTP_409_CONFLICT) new_attr = AppAttr.objects.create(name=serializer.data['name'], app_id=serializer.data['app'], project=get_project_object(project)) new_serializer = AppAttrSerializer(new_attr) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def put(self, request, project, pk): serializer = AppAttrSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) attr_name = serializer.data['name'] attr_list = AppAttr.objects.filter( name=serializer.validated_data['name'], app=serializer.validated_data['app'], project=get_project_object(project)) length = len(attr_list) if length > 1 or (length == 1 and attr_list[0].id != pk): return Response( { 'detail': unicode( "Found same name attr, please check your attr name.") }, status=status.HTTP_409_CONFLICT) attr_obj = get_object(AppAttr, project, pk) attr_obj.name = attr_name attr_obj.save() new_serializer = AppAttrSerializer(attr_obj) return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
def post(self, request,project,pk): serializer=SpdkTrendResultSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: #id = serializer.validated_data['id'] trend_iops=serializer.validated_data['trend_iops'] trend_latency=serializer.validated_data['trend_latency'] testexecution = serializer.validated_data['testexecution'] rw_method = serializer.validated_data['rw_method'] queue_depth = serializer.validated_data['queue_depth'] io_size = serializer.validated_data['io_size'] #time=serializer.validated_data['time'] except KeyError: pass #return Response({'detail': unicode("The lack of required parameters.")}, # status=status.HTTP_400_BAD_REQUEST) new_testsuit_result=SpdkAvgTrendTable.objects.create( #id=id, trend_iops=trend_iops, trend_latency=trend_latency, testexecution=testexecution, #create_time=create_time, rw_method = rw_method, queue_depth = queue_depth, io_size = io_size, project=get_project_object(project) ) new_serializer = SpdkTrendResultSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request,project,pk): serializer=TestsuiteResultSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: #id = serializer.validated_data['id'] testexecution=serializer.validated_data['testexecution'] testsuite=serializer.validated_data['testsuite'] passed=serializer.validated_data['passed'] failed=serializer.validated_data['failed'] block=serializer.validated_data['block'] na =serializer.validated_data['na'] total=serializer.validated_data['total'] #time=serializer.validated_data['time'] except KeyError: pass #return Response({'detail': unicode("The lack of required parameters.")}, # status=status.HTTP_400_BAD_REQUEST) new_testsuit_result=TestSuiteResult.objects.create( #id=id, testexecution=testexecution, testsuite=testsuite, passed=passed, failed=failed, block=block, na=na, total=total, #time=time, project=get_project_object(project) ) #new_testsuit_result.save() new_serializer = TestsuiteResultSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request,project,pk): serializer=MySuiteResultSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: #id = serializer.validated_data['id'] testexecution=serializer.validated_data['testexecution'] testsuite=serializer.validated_data['testsuite'] zero_loss_throughput=serializer.validated_data['zero_loss_throughput'] zero_loss_rate=serializer.validated_data['zero_loss_rate'] #time=serializer.validated_data['time'] except KeyError: pass #return Response({'detail': unicode("The lack of required parameters.")}, # status=status.HTTP_400_BAD_REQUEST) new_testsuit_result=MySuiteResult.objects.create( #id=id, testexecution=testexecution, testsuite=testsuite, zero_loss_throughput=zero_loss_throughput, zero_loss_rate=zero_loss_rate, #time=time, project=get_project_object(project) ) new_serializer = MySuiteResultSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = PerDPDKTestcaseResultDetailSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: perf_dpdk_testcase_result = serializer.validated_data[ 'perf_dpdk_testcase_result'] key = serializer.validated_data['key'] value = serializer.validated_data['value'] app = serializer.validated_data['app'] group = serializer.validated_data['group'] except KeyError: return Response( {'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) if perf_dpdk_testcase_result.app != app: return Response( { 'detail': unicode("The attribute app not match testcase result.") }, status=status.HTTP_400_BAD_REQUEST) if not check_app_attr(key, app, project): return Response( { 'detail': unicode("app ({}) not have attribute ({})".format( app.name, key.name)) }, status=status.HTTP_400_BAD_REQUEST) if PerfDPDKTestCaseResultDetail.objects.filter( perf_dpdk_testcase_result=perf_dpdk_testcase_result, key=key, app=app, group=group, project__name=project).count(): return Response( { 'detail': unicode("perf_dpdk_testcase result detail already exist." "please use PUT method to update result detail.") }, status=status.HTTP_409_CONFLICT) new_result_detail = PerfDPDKTestCaseResultDetail.objects.create( perf_dpdk_testcase_result=perf_dpdk_testcase_result, key=key, value=value, app=app, group=group, project=get_project_object(project)) new_result_detail.save() serializer = PerDPDKTestcaseResultDetailSerializer(new_result_detail) return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestcaseSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: case_name = serializer.validated_data['name'] case_type = serializer.validated_data['type'] case_description = serializer.validated_data['description'] case_script_path = serializer.validated_data['script_path'] case_config_path = serializer.validated_data['config_path'] case_parameters = serializer.validated_data['parameters'] case_feature = serializer.validated_data['feature'] suite_list = serializer.validated_data['testsuite'] except KeyError: return Response({'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) perf = serializer.validated_data.get('performance', False) app = serializer.validated_data.get('app', None) if perf and not app: return Response({'detail': unicode("parameter app must provide when performance=True")}, status=status.HTTP_400_BAD_REQUEST) if not perf and app: return Response({'detail': unicode("parameter app can not be set when performance=False")}, status=status.HTTP_400_BAD_REQUEST) if not check_name(TestCase, case_name, project, check_flag=True): return Response({'detail': unicode("Found same name testcase, " "please check your testcase name.")}, status=status.HTTP_409_CONFLICT) for suite in suite_list: if suite.performance != perf or suite.app != app: return Response({'detail': unicode("suite:{0} not match test case of " "performance type".format(suite.id))}, status=status.HTTP_409_CONFLICT) new_case = TestCase.objects.create( name=case_name, type=case_type, description=case_description, script_path=case_script_path, config_path=case_config_path, parameters=case_parameters, feature=case_feature, performance=perf, app=app, project=get_project_object(project) ) for suite in suite_list: new_case.testsuite.add(suite) new_case.save() new_serializer = TestcaseSerializer(new_case) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): # check post data serializer = TestexecutionSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) # check execution name execution_name = serializer.validated_data['name'] rw = serializer.validated_data['rw'] io_size = serializer.validated_data['io_size'] queue_depth = serializer.validated_data['queue_depth'] environment = serializer.validated_data['environment'] #if not check_name(TestExecution, execution_name, project): # return Response({'detail': unicode("Found same name execution, " # "please check your execution name.")}, # status=status.HTTP_409_CONFLICT) # check os and platform #os = serializer.validated_data['os'] #if not self._check_os(os.id, project): # return Response({'detail': unicode("Not found os({}), please check your os id.".format(os.id))}, # status=status.HTTP_400_BAD_REQUEST) #platform = serializer.validated_data['platform'] #if not self._check_platform(platform.id, project): # return Response({'detail': unicode("Not found platform({}), please check your platform id.".format(platform.id))}, # status=status.HTTP_400_BAD_REQUEST) testplan = serializer.validated_data.get('testplan') #if testplan.category and 'undated' == testplan.category.name: # count = TestExecution.objects.filter(testplan=testplan).count() # if count > 0: # return Response('execution already exist(This is undated test plan, ' # 'just only have one execution).', # status=status.HTTP_400_BAD_REQUEST) runner = serializer.validated_data['runner'] #if not check_owner_runner(request.user, runner): # return Response({'detail': unicode("The runner should be current user - {0}".format(request.user))}, # status=status.HTTP_400_BAD_REQUEST) new_execution = TestExecution.objects.create( name=execution_name, rw=rw, io_size=io_size, queue_depth=queue_depth, testplan=testplan, runner=runner, environment=environment, project=get_project_object(project) ) serializer = TestexecutionSerializer(new_execution) return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request,project,pk): serializer=CaseTypeSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: case_type = CaseTypeserializer.validated_data['case_type'] except KeyError: pass new_testsuit_result=Firmware.objects.create( case_type = case_type, project=get_project_object(project) ) new_serializer = CaseTypeSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestPlanSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: plan_name = serializer.validated_data['name'] rw = serializer.validated_data['rw'] io_size = serializer.validated_data['io_size'] queue_depth = serializer.validated_data['queue_depth'] owner = serializer.validated_data['owner'] plan_description = serializer.validated_data['description'] create_time = serializer.validated_data['create_time'] except KeyError: pass # return Response({'detail': unicode("The lack of required parameters.")}, # status=status.HTTP_400_BAD_REQUEST) #perf = serializer.validated_data.get('performance', False) #app = serializer.validated_data.get('app', None) #if perf and not app: # return Response({'detail': unicode("parameter app must provide when performance=True")}, # status=status.HTTP_400_BAD_REQUEST) #if not perf and app: # return Response({'detail': unicode("parameter app can not be set when performance=False")}, # status=status.HTTP_400_BAD_REQUEST) #if not check_name(TestPlan, plan_name, project, check_flag=True): #return Response({'detail': unicode("Found same name testplan, " # "please check your testplan name.")}, # status=status.HTTP_409_CONFLICT) #if not check_owner_runner(request.user, plan_owner): # return Response({'detail': unicode("The owner should be current user - {0}".format(request.user))}, # status=status.HTTP_400_BAD_REQUEST) new_plan = TestPlan.objects.create( name=plan_name, rw=rw, io_size=io_size, queue_depth=queue_depth, owner=owner, #start_time=start_time, #end_time=end_time, description=plan_description, project=get_project_object(project)) new_serializer = TestPlanSerializer(new_plan) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestexecutionOsSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) os_name = serializer.data['name'] if not check_name(OS, os_name, project): return Response({'detail': unicode("Found same name OS, please check your OS name.")}, status=status.HTTP_409_CONFLICT) new_os = OS.objects.create(name=os_name, project=get_project_object(project)) new_os.save() new_serializer = TestexecutionOsSerializer(new_os) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestexecutionPlatformSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) platform_name = serializer.data['name'] if not check_name(Platform, platform_name, project): return Response({'detail': unicode("Found same name platform, please check your platform name.")}, status=status.HTTP_409_CONFLICT) new_platform = Platform.objects.create(name=platform_name, project=get_project_object(project)) new_platform.save() new_serializer = TestexecutionPlatformSerializer(new_platform) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestsuiteSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: suite_name = serializer.validated_data['name'] suite_subsystem = serializer.validated_data['subsystem'] suite_description = serializer.validated_data['description'] plan_list = serializer.validated_data['testplan'] except KeyError: return Response({'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) perf = serializer.validated_data.get('performance', False) app = serializer.validated_data.get('app', None) if perf and not app: return Response({'detail': unicode("parameter app must provide when performance=True")}, status=status.HTTP_400_BAD_REQUEST) if not perf and app: return Response({'detail': unicode("parameter app can not be set when performance=False")}, status=status.HTTP_400_BAD_REQUEST) if not check_name(TestSuite, suite_name, project, check_flag=True): return Response({'detail': unicode("Found same name testsuite, " "please check your testsuite name.")}, status=status.HTTP_409_CONFLICT) for plan in plan_list: if plan.performance != perf or plan.app != app: return Response({'detail': unicode("plan:{0} not match test suite of " "performance type".format(plan.id))}, status=status.HTTP_409_CONFLICT) new_suite = TestSuite.objects.create( name=suite_name, subsystem=suite_subsystem, performance=perf, app=app, description=suite_description, project=get_project_object(project) ) for plan in plan_list: new_suite.testplan.add(plan) new_suite.save() new_serializer = TestsuiteSerializer(new_suite) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request,project,pk): serializer=io_sizeSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: size=serializer.validated_data['io_size'] except KeyError: pass #return Response({'detail': unicode("The lack of required parameters.")}, # status=status.HTTP_400_BAD_REQUEST) new_testsuit_result = io_size.objects.create( io_size = size, project=get_project_object(project) ) new_serializer = io_sizeSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestcaseTypeSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) type_name = serializer.data['name'] if not check_name(TestCaseType, type_name, project): return Response({'detail': unicode("Found same name type, please check your type name.")}, status=status.HTTP_409_CONFLICT) new_type = TestCaseType.objects.create( name=type_name, project=get_project_object(project) ) new_serializer = TestcaseTypeSerializer(new_type) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def xxx(self, request, project): serializer = TestcaseResultSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: testcase = serializer.validated_data['testcase'] suite_result = serializer.validated_data['testsuite_result'] result = str(serializer.validated_data['result']).lower() bug = serializer.validated_data['bug'] log = serializer.validated_data['log'] comments = serializer.validated_data['comments'] except KeyError: return Response( {'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) message = check_case_in_suite(testcase, suite_result) if message: return Response(message, status=status.HTTP_400_BAD_REQUEST) if TestCaseResult.objects.filter(testcase=testcase, testsuite_result=suite_result, project__name=project).count(): return Response( { 'detail': unicode("Testcase result already exist. " "please use PUT method to update result.") }, status=status.HTTP_409_CONFLICT) new_result = TestCaseResult.objects.create( testcase=testcase, testsuite_result=suite_result, result=result, bug=bug, log=log, comments=comments, project=get_project_object(project)) new_result.save() serializer = TestcaseResultSerializer(new_result) return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request,project,pk): serializer=NvmeDriverTrendResultSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: #id = serializer.validated_data['id'] trend_iops=serializer.validated_data['trend_iops'] trend_latency=serializer.validated_data['trend_latency'] testexecution = serializer.validated_data['testexecution'] rw_method = serializer.validated_data['rw_method'] queue_depth = serializer.validated_data['queue_depth'] io_size = serializer.validated_data['io_size'] MBps = serializer.validated_data['MBps'] workload_mix = serializer.validated_data['workload_mix'] Core_Mask = serializer.validated_data['Core_Mask'] run_time = serializer.validated_data['run_time'] Average_lat = serializer.validated_data['Average_lat'] Min_lat = serializer.validated_data['Min_lat'] Max_lat = serializer.validated_data['Max_lat'] #time=serializer.validated_data['time'] except KeyError: pass #return Response({'detail': unicode("The lack of required parameters.")}, # status=status.HTTP_400_BAD_REQUEST) new_testsuit_result=NvmeDriverTrendTable.objects.create( #id=id, trend_iops=trend_iops, trend_latency=trend_latency, testexecution=testexecution, MBps = MBps, #create_time=create_time, rw_method = rw_method, queue_depth = queue_depth, io_size = io_size, workload_mix = workload_mix, Core_Mask = Core_Mask, run_time = run_time, Average_lat = Average_lat, Min_lat = Min_lat, Max_lat = Max_lat, project=get_project_object(project) ) new_serializer = NvmeDriverTrendResultSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestsuiteSubsystemSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) subsystem_name = serializer.data['name'] if not check_name(Subsystem, subsystem_name, project): return Response({'detail': unicode("Found same name subsystem, " "please check your subsystem name.")}, status=status.HTTP_409_CONFLICT) new_subsystem = Subsystem.objects.create( name=subsystem_name, project=get_project_object(project) ) new_serializer = TestsuiteSubsystemSerializer(new_subsystem) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request,project,pk): serializer=TestRecordSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: case_name = serializer.validated_data['case_name'] case_type=serializer.validated_data['case_type'] branch_commit_id= serializer.validated_data['branch_commit_id'] commit_info=serializer.validated_data['commit_info'] test_command = serializer.validated_data['test_command'] board_name = serializer.validated_data['board_name'] cpu_info = serializer.validated_data['cpu_info'] memory_info = serializer.validated_data['memory_info'] nic_name = serializer.validated_data['nic_name'] device = serializer.validated_data['device'] firmware= serializer.validated_data['firmware'] distro_info = serializer.validated_data['distro_info'] kernel_info = serializer.validated_data['kernel_info'] gcc_info = serializer.validated_data['gcc_info'] #time=serializer.validated_data['time'] except KeyError: pass #return Response({'detail': unicode("The lack of required parameters.")}, # status=status.HTTP_400_BAD_REQUEST) new_testsuit_result=TestRecordTable.objects.create( case_name=case_name, case_type=case_type, branch_commit_id=branch_commit_id, commit_info=commit_info, test_command=test_command, board_name=board_name, cpu_info=cpu_info, nic_name=nic_name, device=device, firmware=firmware, distro_info = distro_info, kernel_info = kernel_info, gcc_info = gcc_info, #time=time, project=get_project_object(project) ) new_serializer = TestRecordSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request,project,pk): serializer=NicPerfTableSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: frame_size = serializer.validated_data['frame_size'] thoughput = serializer.validated_data['thoughput'] send_rate = serializer.validated_data['send_rate'] expected_thoughput = serializer.validated_data['expected_thoughput'] except KeyError: pass new_testsuit_result=NicPerfTable.objects.create( frame_size = frame_size, thoughput = thoughput, send_rate = send_rate, expected_thoughput = expected_thoughput, project=get_project_object(project) ) new_serializer = NicPerfTableSerializer(new_testsuit_result) return Response(new_serializer.data,status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = AppSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) app_name = serializer.data['name'] if not check_name(App, app_name, project): return Response( { 'detail': unicode("Found same name app, please check your app name.") }, status=status.HTTP_409_CONFLICT) new_app = App.objects.create(name=app_name, project=get_project_object(project)) new_app.save() new_serializer = AppSerializer(new_app) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): serializer = TestPlanCategorySerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) category_name = serializer.data['name'] if not check_name(Category, category_name, project): return Response( { 'detail': unicode("Found same name category, " "please check your category name.") }, status=status.HTTP_409_CONFLICT) new_category = Category.objects.create( name=category_name, project=get_project_object(project)) new_serializer = TestPlanCategorySerializer(new_category) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): auth_status, message = check_auth(request.user, project, 'writer') if not auth_status: return Response(message, status=status.HTTP_401_UNAUTHORIZED) serializer = FeatureSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: fea_name = serializer.data['name'] fea_owner = serializer.data['owner'] fea_component = serializer.data['component'] fea_requirement = serializer.data['requirement'] fea_description = serializer.data['description'] except KeyError: return Response({'detail': unicode("The lack of required parameters.")}, status=status.HTTP_400_BAD_REQUEST) if not check_name(Feature, fea_name, project): return Response({'detail': unicode("Found same name feature, " "please check your feature name.")}, status=status.HTTP_409_CONFLICT) if not check_owner_runner(request.user, fea_owner): return Response({'detail': unicode("The owner should be current user - {0}".format(request.user))}, status=status.HTTP_400_BAD_REQUEST) new_fea = Feature.objects.create( name=fea_name, owner=fea_owner, component_id=fea_component, requirement_id=fea_requirement, description=fea_description, project=get_project_object(project) ) new_serializer = FeatureSerializer(new_fea) return Response(new_serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, project): auth_status, message = check_auth(request.user, project, 'writer') if not auth_status: return Response(message, status=status.HTTP_401_UNAUTHORIZED) serializer = FeatureComponentSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) component_name = serializer.data['name'] if not check_name(Component, component_name, project): return Response({'detail': unicode("Found same name componet, " "please check your componet name.")}, status=status.HTTP_409_CONFLICT) new_component = Component.objects.create( name=component_name, project=get_project_object(project) ) new_serializer = FeatureComponentSerializer(new_component) return Response(new_serializer.data, status=status.HTTP_201_CREATED)