def put(self, request, pk, format=None):
task = self.get_object(pk)
serializer = TaskSerializer(task, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def task(request, pk):
if request.method == 'GET':
try:
task = Task.objects.get(pk=pk, user=request.user)
except Task.DoesNotExist:
raise Http404()
serializer = TaskSerializer(task)
form = TaskForm(request.POST or None,
initial={
'title': task.title,
'description': task.description,
'deadline': task.deadline,
'status': task.status,
'priority': task.priority
})
return render(request, 'tasks/task.html', {
'form': form,
'task_id': task.id,
})
if request.method == 'POST':
try:
task = Task.objects.filter(pk=pk, user=request.user)
except Task.DoesNotExist:
raise Http404()
serializer = TaskSerializer(data=request.POST)
if serializer.is_valid():
task.update(**serializer.data)
form = TaskForm(
request.POST or None
) #, initial={'title':task.title, 'description':task.description, 'deadline':task.deadline, 'status':task.status, 'priority':task.priority})
return render(request, 'tasks/task.html', {
'form': form,
'task_id': pk,
})
def post(self, request, format=None):
user = User.objects.first()
serializer = TaskSerializer(data=request.data, context={'user': user})
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 update(self, request, pk):
task = self.get_obj_and_check_permission(Task, request, pk)
serializer = TaskSerializer(task, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = TaskSerializer(data=request.data,
context={'request': request})
if (serializer.is_valid()):
serializer.save(owner=self.request.user) # set current user?
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = TaskSerializer(data=request.data)
if serializer.is_valid():
serializer.validated_data['owner_id'] = request.user.id # without this i get
# IntegrityError: null value in column "owner_id" violates not-null constraint error
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, task_id):
task = Task.objects.get(pk=task_id)
serializer = TaskSerializer(instance=task, data=request.data)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response(data=serializer.data, status=status.HTTP_200_OK)
return Response(data=serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def push_sub_task(self, request, pk=None):
serializer = TaskSerializer(data=request.data)
if serializer.is_valid():
parent_task = get_object_or_404(self.queryset, pk=pk)
parent_task.push_sub_task(**serializer.validated_data)
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors,
status=status.HTTP_406_NOT_ACCEPTABLE)
def partial_update(self, request, pk=None):
serializer = TaskSerializer(data=request.data)
if serializer.is_valid():
project = get_object_or_404(self.queryset, pk=pk)
self.check_object_permissions(request, project)
serializer.update(project, serializer.validated_data)
return Response(status=status.HTTP_200_OK)
else:
return Response(serializer.errors,
status=status.HTTP_406_NOT_ACCEPTABLE)
def post(self, request, *args, **kwargs):
serializer = TaskSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
print(request.data)
serializer.save()
return Response(data={},
status=status.HTTP_201_CREATED,
template_name='tasks/create-task.html')
print(serializer.errors)
return Response(data=serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk, action):
task = Task.objects.filter(
Q(created_by=request.user.pk)
| Q(assigned_by=request.user.pk)).get(pk=pk)
serializer = TaskSerializer(task, data=request.data)
if action == 'update':
if serializer.is_valid():
serializer.save()
return HttpResponseRedirect(reverse('view_task'))
def patch(self, request, format=None, *args, **kwargs):
try:
task = Task.objects.get(id=self.kwargs['pk'])
serializer = TaskSerializer(task, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data,
status=status.HTTP_201_CREATED)
except Task.DoesNotExist:
error = {'error': 'No Tasks Exist'}
return Response(data=error, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, project_id=None):
# TODO add project admin assigment option
project = get_object_or_404(Project.objects.all(),
id=project_id,
owner=request.user)
self.check_object_permissions(request, project)
serializer = TaskSerializer(data=request.data,
context={'request': request})
if serializer.is_valid():
serializer.save(project=project)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_406_NOT_ACCEPTABLE)
def post(self, request):
try:
user_id = resolve_user_id_from_jwt(request)
request_data = request.data
task_serializer = TaskCreateSerializer(
data={**request_data, 'user': user_id})
if not task_serializer.is_valid():
print(task_serializer.initial_data)
return StandardResponse(errors=task_serializer.errors)
else:
task_id = request_data.get('uuid', None)
try:
if not Task.objects.filter(uuid=task_id).exists():
task = task_serializer.save(user_id=user_id)
return StandardResponse(TaskSerializer(task).data)
task = Task.objects.get(uuid=task_id)
project = task.project
label = task.label
section = task.section
parent = task.parent
for field in ['project', 'label', 'section', 'parent']:
form_data = request_data.get(field)
if form_data:
if field == 'project':
project = Project.objects.get(pk=form_data)
if field == 'label':
label = Label.objects.get(pk=form_data)
if field == 'section':
section = Section.objects.get(pk=form_data)
if field == 'parent':
parent = Task.objects.get(pk=form_data)
task.title = request_data.get('title', task.title)
task.project = project
task.label = label
task.due_date = request_data.get(
'due_date', task.due_date)
task.priority = request_data.get(
'priority', task.priority)
task.section = section
task.parent = parent
task.checked = request_data.get(
'checked', task.checked)
task.order = request_data.get('order', task.order)
task.save()
return StandardResponse(TaskSerializer(task).data)
except Exception as e:
return StandardResponse(errors=str(e))
except Exception as e:
return StandardResponse(errors=str(e))
def task_list(request):
if request.method == 'POST':
serializer = TaskSerializer(data=request.POST)
if serializer.is_valid():
task = Task.objects.create(user=request.user, **serializer.data)
else:
raise SuspiciousOperation('Invalid Data')
form = TaskForm()
query = dict(request.GET.items())
tasks = Task.objects.filter(user=request.user, **query)
serializer = TaskSerializer(tasks, many=True)
context = {'tasks_list': serializer.data, 'form': form}
return render(request, 'tasks/task_list.html', context)
def get(self, request):
# get a task
filters = {"user": request.user}
for key in request.GET:
if key != "page":
filters[key] = request.GET[key]
try:
print(filters)
tasks = Task.objects.filter(**filters).order_by("due_on")
paginator = PageNumberPagination()
paginator.page_size = 15
result_page = paginator.paginate_queryset(tasks, request)
serializer = TaskSerializer(result_page,
many=True,
context={"request": request})
return Response({
"current_page": request.GET['page'],
"total_pages": math.ceil(len(tasks) / 15),
"count": len(result_page),
"data": serializer.data
})
except KeyError:
return Response(data={
"message":
"Bad request. The allowed fields are given in this response. You can use standard Django Queryset filters",
"allowed_fields":
"created_at, desc, due_on, labels, name, status, subtasks, user, user_id, uuid"
},
status=status.HTTP_400_BAD_REQUEST)
def perform_create(self, serializer):
"""Save the post data when creating a new race."""
data = self.request.data
keyword = data.get('keyword')
agents = []
if len(self.request.POST.getlist('agent')):
agents = self.request.POST.getlist('agent')
elif 'agents' in data:
# try
agents = data.get('agents')
race = serializer.save(keyword=keyword, agents=agents)
# get race tasks
tasks = []
for racetask in race.racetask_set.all():
tasks.append(TaskSerializer(racetask.task).data)
broadcast({
'keyword': keyword,
'id': race.id,
'tasks': tasks,
'message': 'race_started'
})
def add_task(request, flat_id=None):
name = request.data.get('name', None)
user_ids = request.data.get('users', None)
frequency = request.data.get('frequency', None)
if name is None or user_ids is None or frequency is None:
return Response(data={'message': 'Wrong parameters'}, status=400)
if frequency not in ['DAILY', 'WEEKLY', 'MONTHLY']:
return Response(
data={'message': 'Frequency can be: DAILY, WEEKLY, MONTHLY'},
status=400)
try:
flat = Flat.objects.get(id=flat_id)
except ObjectDoesNotExist:
return Response(
data={'message': 'The flat {0} does not exist.'.format(flat_id)},
status=400)
user_list = []
for user_id in user_ids.split(','):
try:
user = User.objects.get(id=user_id)
if user not in flat.users.all():
return Response(data={
'message':
'{0} is not a member of the flat.'.format(user.username)
},
status=400)
user_list.append(user)
except ObjectDoesNotExist:
return Response(data={
'message':
'The user id {0} does not exist.'.format(user_id)
},
status=400)
rule = Rule(frequency=frequency, name='{0}_{1}'.format(frequency, name))
rule.save()
event = Event(rule=rule,
start=datetime.now(),
end=datetime.now() + timedelta(days=60),
calendar=Calendar.objects.get_calendar_for_object(flat))
event.save()
task = Task(flat=flat, name=name, event=event)
task.save()
for u in user_list:
task.users.add(u)
task.refresh_from_db()
return Response(data={
'message': 'Your task has been created.',
'task': TaskSerializer(task).data,
},
status=200)
def get(self, request):
try:
user_id = resolve_user_id_from_jwt(request)
tasks = Task.objects.filter(user_id=user_id)
return StandardResponse(TaskSerializer(tasks, many=True).data,)
except Exception as e:
return StandardResponse(errors=str(e))
class ProjectDetailSerializer(ProjectSerializer):
participants = BasicUserDataSerializer(required=False, many=True)
owner = BasicUserDataSerializer(required=False)
assignedTasks = TaskSerializer(read_only=True, many=True)
class Meta:
model = Project
fields = (
'id',
'owner',
'project_name',
'description',
'participants',
'assignedTasks',
)
extra_kwargs = {
'id': {
'read_only': True,
'required': False
},
'owner': {
'read_only': True,
'required': False
},
'project_name': {
'required': True
},
'description': {
'required': False
},
'participants': {
'required': False,
'read_only': True
},
}
def run_task_predictions(ml_backend_id, batch_size=100):
"""
Run prediction and update db, stats counts and project prerequisites
:param project_id:
:param batch_size:
:return:
"""
ml_backend = MLBackend.objects.get(id=ml_backend_id)
response = ml_backend.setup()
if response.is_error:
raise ValueError(response.error_message)
else:
if response.response['model_version'] != ml_backend.model_version:
ml_backend.model_version = response.response['model_version']
ml_backend.save()
# collect tasks without predictions for current model version
tasks_without_predictions = ml_backend.project.tasks.annotate(
model_version=F('predictions__model_version'),
num_predictions=Count('predictions')
).filter(~Q(model_version=ml_backend.model_version) | Q(num_predictions=0))
if not tasks_without_predictions.exists():
logger.info(f'Predictions for project {ml_backend.project} with version {ml_backend.model_version} already exist, '
f'update is not needed')
return {'status': 'ok'}
else:
logger.info(f'Found {tasks_without_predictions.count()} tasks without predictions '
f'from model version {ml_backend.model_version} in project {ml_backend.project}')
# TODO: randomize tasks selection so that taken tasks don't clash with each other with high probability
tasks = TaskSerializer(tasks_without_predictions[:batch_size], many=True).data
failed_tasks = []
for task in tasks:
task_id = task['id']
ml_api_result = ml_backend.api.make_predictions([task], ml_backend.model_version, ml_backend.project)
if not _validate_ml_api_result(ml_api_result, [task], logger):
logger.warning(f'Project {ml_backend.project}: task {task.id} failed')
failed_tasks.append(task)
continue
prediction_result = ml_api_result.response['results'][0]
with transaction.atomic():
Prediction.objects.filter(task_id=task_id, model_version=ml_backend.model_version).delete()
Prediction.objects.create(
task_id=task_id,
model_version=ml_backend.model_version,
result=prediction_result['result'],
score=safe_float(prediction_result.get('score', 0)),
cluster=prediction_result.get('cluster'),
neighbors=prediction_result.get('neighbors'),
mislabeling=safe_float(prediction_result.get('mislabeling', 0))
)
logger.info(f'Project {ml_backend.project}: task {task_id} processed with model version {ml_backend.model_version}')
MLBackendPredictionJob.objects.filter(job_id=get_current_job().id).delete()
logger.info(f'Total task processes: {len(tasks)}, failed: {len(failed_tasks)}')
return {'status': 'ok', 'processed_num': len(tasks), 'failed': failed_tasks}
def tasks(self, request, pk=None):
# Get User from request
user = request.user
# Get Answered tasks from Answer that User've solved
answered_task_pks = Answer.objects.filter(
owned_by=user,
task__main_topic__pk=pk,
).values_list(
'task', flat=True
)
tasks = Task.objects.filter(
main_topic__topic__pk=pk,
order__isnull=False,
)
tasks_data = TaskSerializer(
tasks,
many=True,
context={
'request': request
},
).data
# Add `"answered": True,` for answered tasks
tasks_serializer = [
self._add_answered_status(task, answered_task_pks)
for task in tasks_data
]
return Response(tasks_serializer)
def task_list(request):
if request.method == 'GET':
tasks = Task.objects.all()
tasks_serializer = TaskSerializer(tasks, many=True)
return JsonResponse(tasks_serializer.data, safe=False)
elif request.method == 'POST':
try:
task_data = JSONParser().parse(request)
task_name = task_data.get('task_name', "default task name")
task_description = task_data.get('task_description', "default task description")
task_start_date = task_data.get('task_start_date', datetime.datetime.now())
if task_start_date == '':
task_start_date = datetime.datetime.now()
task_end_date = task_data.get('task_end_date', datetime.datetime.now())
if task_end_date == '':
task_end_date = datetime.datetime.now()
related_project_name = task_data.get('task_project_name', "default task description")
project = Project.objects.get(name=related_project_name)
task = Task(name=task_name, description=task_description, start_date=task_start_date,
end_date=task_end_date, project=project)
task.save()
return HttpResponse(status=status.HTTP_201_CREATED)
except:
return HttpResponse(status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
Task.objects.all().delete()
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def get(self, request, *args, **kwargs):
tasks = Task.objects.all()
serializer = TaskSerializer(instance=tasks, many=True)
context = {'tasks': serializer.data, 'user': request.user}
return Response(data=context,
status=status.HTTP_201_CREATED,
template_name='tasks/tasks.html')
def get(self, request, format=None, *args, **kwargs):
try:
task = Task.objects.get(id=self.kwargs['pk'])
serializer = TaskSerializer(task, many=False)
return Response(serializer.data)
except Task.DoesNotExist:
error = {'error': 'No Tasks Exist'}
return Response(data=error, status=status.HTTP_400_BAD_REQUEST)
class ReviewSerializer(serializers.ModelSerializer):
to_user = UserAccountSerializer()
from_user = UserAccountSerializer()
task = TaskSerializer()
class Meta:
model = Review
fields = ('id', 'to_user', 'from_user', 'task', 'content', 'mark')
def test_retrieve_task(self, task: Task):
path = reverse('tasks:task-detail', kwargs={'id': task.id})
request = self.factory.get(path)
response = TasksViewSet.as_view({'get': 'retrieve'})(request,
id=task.id)
assert response.status_code == 200
assert response.data == TaskSerializer(task).data
def get(self, request):
menu = gs.get_menu(request.user)
serializer = TaskSerializer()
return Response({
'serializer': serializer,
'menu': menu
},
template_name=self.template_name)
def task_detail(request, pk):
"""
Get, udpate, or delete a specific task
"""
try:
task = Task.objects.get(pk=pk)
except Task.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = TaskSerializer(task)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = TaskSerializer(task, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serilizer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
task.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
class NotificationSerializer(ModelSerializer):
task = TaskSerializer()
from_user = UserAccountSerializer()
to_user = UserAccountSerializer()
class Meta:
fields = ('id', 'task', 'from_user', 'to_user', 'send_date', 'content',
'status', 'notification_type')
model = Notification
def pending(request):
form = TaskForm()
query = dict(request.GET.items())
pending = Task.objects.filter(user=request.user,
status=Task.PENDING,
**query)
serializer = TaskSerializer(pending, many=True)
context = {'tasks_list': serializer.data, 'form': form}
return render(request, 'tasks/task_list.html', context)