def create(self, validated_data):
user_id = validated_data['user'].id
biz_type = validated_data['business_type']
biz_stage = validated_data['business_stage']
exist = TaskPackages.objects.filter(user_id=user_id).filter(
business_type=biz_type).filter(
status=getenum_task_package_status('ongoing'))
if exist:
raise ValidationError({
"detail":
_("Only one task package per type and stage can be created.")
})
if task_to_arrange(biz_type, biz_stage):
due_days = validated_data['size'] / validated_data['daily_plan']
c_t = timezone.now()
due_date = c_t + timezone.timedelta(days=due_days)
validated_data['due_date'] = due_date
validated_data['c_t'] = c_t
task_package = TaskPackages.objects.create(**validated_data)
task_package.save()
# 分配第一个任务
assign_task(biz_type, biz_stage, task_package,
validated_data['user'])
return task_package
else:
raise ValidationError(
{"detail": _("No more tasks, come back tomorrow!")})
def submit_and_next(self, request, *args, **kwargs):
variants_dedup = self.get_object()
origin_task = update_tasks_status(variants_dedup)
if origin_task:
task_package = origin_task.task_package
task_plan = task_package.size
business_type = origin_task.business_type
task_num = len(
list(task_package.tasks.filter(business_type=business_type)))
if task_num < task_plan:
business_stage = origin_task.business_stage
user = origin_task.user
new_task = assign_task(business_type, business_stage,
task_package, user)
if type(new_task) is not Response:
serializer = self.serializer_class(new_task.content_object)
return Response(serializer.data)
else:
return Response(
_("No more task today, have a try tommorrow!"),
status=status.HTTP_204_NO_CONTENT)
else:
return Response(_(
"This package is completed, please apply for a new one!"),
status=status.HTTP_100_CONTINUE)
return Response(_("Inputdata Error!"),
status=status.HTTP_400_BAD_REQUEST)
def ongoing_split(self, request, *args, **kwargs):
"""
列出当前进行中的拆字任务
:param request:
:param args:
:param kwargs:
:return:
"""
user = self.request.user
if not has_business_type_perm(user, 'split'):
return HttpResponseForbidden(
_("You don't have permission to view."))
task_package_id = request.query_params.get("task_package_id", 0)
if task_package_id == 0:
return HttpResponseBadRequest(_("ID invalid."))
task_package = TaskPackages.objects.get(pk=task_package_id)
task = get_working_task(task_package, user)
if not task:
task = assign_task(task_package.business_type,
task_package.business_stage, task_package, user)
if task:
serializer = self.get_serializer([task], many=True)
return Response(serializer.data)
return Response(
{"error": _("No more task today, have a try tommorrow!")},
status=status.HTTP_204_NO_CONTENT)
def submit_and_next(self, request, *args, **kwargs):
variants_split = self.get_object()
serializer = VariantsSplitSerializer(data=request.data)
if serializer.is_valid():
origin_task = update_tasks_status(variants_split)
task_ele = origin_task.content_object
for key in serializer.initial_data.keys():
setattr(
task_ele, key,
serializer.initial_data.get(key, getattr(task_ele, key)))
task_ele.save()
task_package = origin_task.task_package
task_plan = task_package.size
task_num = len(list(task_package.tasks.all()))
if task_num < task_plan:
business_type = origin_task.business_type
business_stage = origin_task.business_stage
user = origin_task.user
new_task = assign_task(business_type, business_stage,
task_package, user)
if new_task:
serializer = self.serializer_class(new_task.content_object)
return Response(serializer.data)
else:
return Response(
_("No more task today, have a try tommorrow!"),
status=status.HTTP_204_NO_CONTENT)
else:
return Response(_(
"This package is completed, please apply for a new one!"),
status=status.HTTP_100_CONTINUE)
return Response(_("Inputdata Error!"))
def submit_and_next(self, request, *args, **kwargs):
input_page = self.get_object()
task_package = TaskPackages.objects.get(
pk=int(request.GET['task_package_id']))
business_stage = task_package.business_stage
origin_task = update_status(input_page, business_stage)
if update_task_package(origin_task):
user = origin_task.user
new_task = assign_task(getenum_business_type("input_page"),
business_stage, task_package, user)
if new_task:
id = new_task.object_id
return Response(id, status=status.HTTP_200_OK)
else:
return Response(_("No more task today, have a try tommorrow!"),
status=status.HTTP_204_NO_CONTENT)
else:
return Response(
_("This package is completed, please apply for a new one!"),
status=status.HTTP_100_CONTINUE)
def skip_task(self, request, *args, **kwargs):
"""
太难跳过当前任务, 返回下一条
目前只拆字用
:param request:
:param args:
:param kwargs:
:return:
"""
if not has_business_type_perm(request.user, 'split'):
return HttpResponseForbidden(
_("You don't have permission to view."))
origin_task = Tasks.objects.get(pk=kwargs['pk'])
work_ele = origin_task.content_object
business_type = origin_task.business_type
business_stage = origin_task.business_stage
user = origin_task.user
task_package = origin_task.task_package
if business_stage == getenum_business_stage("init"):
work_ele.skip_num_draft += 1
elif business_stage == getenum_business_stage("review"):
work_ele.skip_num_review += 1
else:
work_ele.skip_num_final += 1
work_ele.save()
new_task = assign_task(business_type, business_stage, task_package,
user)
reset_task(origin_task)
if new_task:
serializer = self.get_serializer([new_task], many=True)
return Response(serializer.data)
else:
return Response(
{"error": _("No more task today, have a try tommorrow!")},
status=status.HTTP_204_NO_CONTENT)
def submit_next_split(self, request, *args, **kwargs):
"""
提交并返回下一条任务数据
:param request:
:param args:
:param kwargs:
:return:
"""
if not has_business_type_perm(request.user, 'split'):
return HttpResponseForbidden(
_("You don't have permission to view."))
business_stage = request.data['business_stage']
business_type = request.data['business_type']
task = Tasks.objects.get(pk=request.data['id'])
split = task.content_object
if business_stage == getenum_business_stage('init'):
if request.data['task_ele']['dup_id_draft'] != '':
split.dup_id_draft = request.data['task_ele']['dup_id_draft']
else:
split.init_split_draft = request.data['task_ele'][
'init_split_draft']
split.other_init_split_draft = request.data['task_ele'][
'other_init_split_draft']
split.deform_split_draft = request.data['task_ele'][
'deform_split_draft']
split.similar_parts_draft = request.data['task_ele'][
'similar_parts_draft']
elif business_stage == getenum_business_stage('review'):
if request.data['task_ele']['dup_id_review'] != '':
split.dup_id_review = request.data['task_ele']['dup_id_review']
else:
split.init_split_review = request.data['task_ele'][
'init_split_review']
split.other_init_split_review = request.data['task_ele'][
'other_init_split_review']
split.deform_split_review = request.data['task_ele'][
'deform_split_review']
split.similar_parts_review = request.data['task_ele'][
'similar_parts_review']
elif business_stage == getenum_business_stage('final'):
if request.data['task_ele']['dup_id_final'] != '':
split.dup_id_final = request.data['task_ele']['dup_id_final']
else:
split.init_split_final = request.data['task_ele'][
'init_split_final']
split.other_init_split_final = request.data['task_ele'][
'other_init_split_final']
split.deform_split_final = request.data['task_ele'][
'deform_split_final']
split.similar_parts_final = request.data['task_ele'][
'similar_parts_final']
split.save()
new_task = assign_task(business_type, business_stage,
task.task_package, task.user)
if new_task:
serializer = self.get_serializer([new_task], many=True)
return Response(serializer.data)
else:
return Response(
{"error": _("No more task today, have a try tommorrow!")},
status=status.HTTP_204_NO_CONTENT)