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)
