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)