def put(self, request, pk, format=None): snippet = self.get_object(pk) serializer = TaskSerializer(snippet, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): user = request.user descendants = user.profile.directing_department.members.all().exclude( id=user.profile.id) if hasattr( user.profile, "directing_department") else user.profile.child_members.all() data = { "descendants": ProfileSerializer(descendants, many=True).data, "profile": ProfileSerializer(user.profile).data, "ancestor": ProfileSerializer(user.profile.manager).data, "tasks": TaskSerializer(user.profile.tasks, many=True).data, "pips": PipSerializer(user.pips.all(), many=True).data if hasattr( user, "pips") else [], "raised_pips": PipSerializer(user.raised_pips.all(), many=True).data if hasattr( user, "raised_pips") else [], "pending_tasks": TaskSerializer(user.profile.pending_tasks, many=True).data, "kras": KraSerializer(user.kras.all(), many=True).data if hasattr( user, "kras") else [] } return Response(utils.build_response(True, None, data))
def put(self, request, pk, format=None): task = self.get_object(pk) request.data["edited"] = datetime.now() serializer = TaskSerializer(task, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk): # ipdb.set_trace() task = get_object_or_404(Task, pk=pk) serializer = TaskSerializer(task, data=request.data) if not serializer.is_valid(): ipdb.set_trace() return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) serializer.save() return Response({'task': get_object_or_404(Task, pk=pk)})
def post(self, request, format=None): owner = request.user serializer_context = {'request': request, } serializer = TaskSerializer(data=request.data, context=serializer_context) if serializer.is_valid(): serializer.save(owner=owner) return self.get(request) else: ipdb.set_trace() return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk, format=None): task = self.get_object(pk) date = datetime.now() if (task.status): date = None data = {"status": not task.status, "concluded": date} serializer = TaskSerializer(task, data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): validate_error = task_validation(request.data) if validate_error is not None: return Response(prepare_error_response(validate_error), status=status.HTTP_400_BAD_REQUEST) serializer = TaskSerializer(data=request.data) if serializer.is_valid(raise_exception=True): serializer.save() return Response(prepare_create_success_response(serializer.data), status=status.HTTP_200_OK) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, survivor_id): request.data['survivor'] = survivor_id request.data['advocate'] = request.user.user_token serializer = TaskSerializer(data=request.data) if serializer.is_valid(raise_exception=True): task = serializer.save() send_push_message(token=Survivor.objects.get( user__user_token=survivor_id).user.device_token, message='task', notification_type='task-assigned', data={'details': task.details}) return Response(TaskSerializer(task).data, status=status.HTTP_201_CREATED)
def view(self, user, pk): ''' checing whether the task id exists or not''' if Task.objects.filter(id=pk).exists(): ''' task instance ''' task = Task.objects.get(id=pk) ''' checking whether the task belongs to the requested user ''' if task.created_by == user: serializer = TaskSerializer(task) ''' success response ''' return Response( { 'success': True, 'message': 'Task details successfully fetched', 'data': serializer.data, }, status=status.HTTP_200_OK) ''' unauthorized access response ''' return Response( { 'success': False, 'error': 'Task does not belong to {}'.format(user.email), }, status=status.HTTP_401_UNAUTHORIZED) ''' invalid task id response ''' return Response({ 'success': False, 'error': 'Invalid Task id', }, status=status.HTTP_404_NOT_FOUND)
def get(self, request, format=None): tasks = Task.objects.filter(owner=request.user) serializer = TaskSerializer(tasks, many=True) # Ojo con el many true if len(tasks) == 0: return Response(status=status.HTTP_204_NO_CONTENT) else: return Response(serializer.data, status=status.HTTP_200_OK)
class FolderSerializer(serializers.ModelSerializer): task_set = TaskSerializer(many=True, read_only=True) class Meta: model = Folder fields = ('id', 'name', 'owner', 'task_set') read_only_fields = ('owner', )
def create(request): if request.method == 'POST': data = JSONParser().parse(request) data["created"] = datetime.today() data["uid"] = uuid.uuid1() data["uid"] = uuid.uuid1() serializer = TaskSerializer(data=data) if serializer.is_valid(): serializer.save() message = MessageGenerator(uid=data["uid"], script=data["script"], arguments=data["arguments"]) messenger.submit(message.generate_message()) return JsonResponse(serializer.data, status=201) return JsonResponse(serializer.errors, status=400) if request.method == 'GET': return HttpResponse(status=405)
def post(self, request): serialized_object = TaskSerializer(data=request.data) if not serialized_object.is_valid(): res = str(serialized_object.errors) Status = status.HTTP_400_BAD_REQUEST message = res response = {"status": Status, "message": message} logger.info("upload_statement response: " + str(response)) return Response(response, Status) message = "Unauthorized" Status = status.HTTP_500_INTERNAL_SERVER_ERROR response = {"message": message, "status": Status} request_params = request.data list_name = request_params.get('list_name') task_name = request_params.get('task_name') description = request_params.get('desc') due_date = request_params.get('due_date') label = request_params.get('label') status_task = request_params.get('status') priority = request_params.get('priority') try: task_obj = Task.objects.create(task_name=task_name, task_desc=description, due_date=due_date, list_name=list_name, label=label, status=status_task, priority=priority) if task_obj: response = { "message": "success", "description": "Data Uploded successfully" } Status = status.HTTP_200_OK except Exception as e: print(e) response = { "message": "error", "description": "Something went wrong" } Status = status.HTTP_500_INTERNAL_SERVER_ERROR return Response(response, Status)
def update(self, pk, data, user): ''' checking whether the tasks id exists or not ''' if Task.objects.filter(id=pk).exists(): ''' getting task object ''' task = Task.objects.get(id=pk) ''' checking whether the task belongs to the requested user ''' if task.created_by == user: serializer = TaskSerializer(data=data, instance=task) ''' checking whether the serializer is valid or not ''' if serializer.is_valid(): ''' updating task details ''' serializer.update(instance=task, validated_data=serializer.validated_data) ''' success response ''' return Response( { 'success': True, 'message': f'Task: {pk}, successfully updated', 'data': serializer.data, }, status=status.HTTP_200_OK) return Response( { 'success': False, 'error': f'Failed to update task: {pk}', 'message': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) ''' unauthorized access response ''' return Response( { 'success': False, 'error': 'Task: {} does not belong to {}'.format(pk, user.email), }, status=status.HTTP_401_UNAUTHORIZED) ''' invalid task id response ''' return Response( { 'success': False, 'error': f'No task found with id: {pk}', }, status=status.HTTP_404_NOT_FOUND)
def view_pk(request, pk): try: task = Task.objects.get(pk=pk) task.arguments = ast.literal_eval(task.arguments) except Task.DoesNotExist: return HttpResponse(status=404) if request.method == 'GET': serializer = TaskSerializer(task) return JsonResponse(serializer.data)
def get_process_tasks(request, id): try: process = models.Process.objects.get(id=id) tasks = Task.objects.filter(process=process) serializer = TaskSerializer(tasks, many=True) return Response({'tasks': serializer.data}) except: return Response({'error': 'Bir hata oluştu'})
def put(self, request, survivor_id): task = Task.objects.get(id=request.data.get('task_id')) task.status = request.data.get('status', task.status) task.type = request.data.get('type', task.type) task.deadline = request.data.get('deadline', task.deadline) task.save() return Response(TaskSerializer(task).data, status=status.HTTP_200_OK)
def put(self, request, pk): validate_error = task_validation(request.data) if validate_error is not None: return Response(prepare_error_response(validate_error), status=status.HTTP_400_BAD_REQUEST) task = self.get_object(pk) if task is not None: serializer = TaskSerializer(task, data=request.data) if serializer.is_valid(): serializer.save() return Response(prepare_create_success_response( serializer.data), status=status.HTTP_201_CREATED) return Response(prepare_error_response(serializer.errors), status=status.HTTP_400_BAD_REQUEST) else: return Response( prepare_error_response("No addons found for this ID"), status=status.HTTP_400_BAD_REQUEST)
def mutate(root, info, data): try: instance = Task.objects.get(id=data['id']) except Task.DoesNotExist: return UpdateTask(errors=[ CustomErrorType(field='nonFieldErrors', messages=[gettext('Task does not exist.')]) ]) serializer = TaskSerializer(instance=instance, data=data, partial=True) if errors := mutation_is_not_valid(serializer): return UpdateTask(errors=errors, ok=False)
class RoundSerializer(serializers.ModelSerializer): author = serializers.SerializerMethodField() tasks = TaskSerializer(many=True) def get_author(self, obj: Round): return obj.tournament.author_id class Meta: model = Round fields = ('id', 'title', 'tournament', 'author', 'is_final', 'is_selection', 'tasks')
def view_uid(request, uid): try: task = Task.objects.get(uid=uid) task.arguments = ast.literal_eval(task.arguments) except Task.DoesNotExist: return HttpResponse(status=404) except ValidationError as e: return HttpResponse(e, status=400) if request.method == 'GET': serializer = TaskSerializer(task) return JsonResponse(serializer.data)
def list(self, user): ''' Filtering tasks based on request user id ''' tasks = Task.objects.filter(created_by=user, is_deleted=False) ''' task serializer ''' serializer = TaskSerializer(tasks, many=True) ''' success response ''' return Response( { 'success': True, 'message': 'Task list successfully fetched', 'data': serializer.data, }, status=status.HTTP_200_OK)
def post(self, request): task_serializer = TaskSerializer(data=request.data) if not task_serializer.is_valid(): return Response(task_serializer.errors, status=http_status_code.HTTP_400_BAD_REQUEST) validated_data = task_serializer.validated_data task = Task.objects.create(task_id=validated_data.get('task_id'), file_id=validated_data.get('file_id'), status=validated_data.get('status'), result=validated_data.get('result')) # # Cache # cache_key = 'task_id' # cache.set(cache_key, "First Task for analysis") # Async call for analysing file. analyze_file.delay(validated_data.get('task_id')) return Response(task_serializer.data, status=http_status_code.HTTP_201_CREATED)
def get(self, request, *args, **kwargs): messages = Message.objects.filter( kra__in=request.user.kras.all(), read=False).exclude(user=request.user) serializer = KraMessagesSerializer(messages, many=True, context={"request": request}) data = {"messages": serializer.data} tasks = request.user.profile.unseen_tasks serializer = TaskSerializer(tasks, many=True) data["tasks"] = serializer.data messages.update(read=True) tasks.update(seen=True) return Response(utils.build_response(True, None, data))
def get(self, request, task_id=None): file_id = request.GET.get('uuid') if file_id: tasks = Task.objects.filter(file_id=file_id) elif task_id: tasks = Task.objects.filter(task_id=task_id) else: tasks = Task.objects.all() serializer = TaskSerializer(tasks, many=True) return Response(serializer.data, status=http_status_code.HTTP_200_OK)
def task_collection(request): #To view all Task Objects if request.method == 'GET': tasks = Task.objects.all() serializer = TaskSerializer(tasks, many=True) #Serialize all value to be sent over return Response(serializer.data) #To create a new Task Object elif request.method == 'POST': data = { 'title' : request.data.get('title'), 'description' : request.data.get('description') } serializer = TaskSerializer(data=data) #If the task serializer is valid then save it, otherwise return 400 bad request 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 create(self, data, user): ''' checking the validity of serializer ''' serializer = TaskSerializer(data=data, context={'user': user}) ''' checking whether the API payload is valid or not ''' if serializer.is_valid(): ''' creating new task''' task = serializer.save() if task: ''' success response ''' return Response( { 'success': True, 'message': 'Task successfully created', 'data': serializer.data, }, status=status.HTTP_201_CREATED) ''' serializer error response ''' return Response( { 'success': False, 'error': 'Failed to create new task', 'message': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST)
def test_retrieve_tasks(self): """Test retrieving authenticated User Tasks""" Task.objects.create(user=self.user, title='First Title', body='First Body') Task.objects.create(user=self.user, title='Second Title', body='Second Body') # HTTP GET request res = self.client.get(TASKS_URL) tasks = Task.objects.all().order_by('date_created') serializer = TaskSerializer(tasks, many=True) # returns MANY Tasks # Assertions self.assertEqual(res.status_code, status.HTTP_200_OK) self.assertEqual(res.data, serializer.data)
def post(self, request): # permission_classes = (IsAuthenticated,) serializer_class = TaskSerializer( data={ "id": self.request.data.get('id'), "name": self.request.data.get('name'), "assignee": self.request.data.get('assignee'), "process_id": self.request.data.get('process_id') }) serializer_class.is_valid() serializer_class.save() url = 'http://dev.cheesenology.kz:8080/engine-rest/task' json = { "taskVariables": [{ "name": self.request.data.get('name'), "value": "varValue", "operator": "eq" }, { "name": self.request.data.get('name'), "value": 30, "operator": "neq" }], "processInstanceBusinessKeyIn": "aBusinessKey,anotherBusinessKey", "assigneeIn": self.request.data.get('assignee'), "priority": 10, "sorting": [{ "sortBy": "dueDate", "sortOrder": "asc" }, { "sortBy": "processVariable", "sortOrder": "desc", "parameters": { "variable": "orderId", "type": "String" } }] } # surname, name = (str(self.request.data.get('fio')) + " ").split(" ", 1) # json = { # "profile": { # "id": str(self.request.data.get('id')), # "name": str(self.request.data.get('name')), # "assignee": int(self.request.data.get('assignee')), # "process_id": str(self.request.data.get('process_id')) # # "credentials": { # # "password": self.request.data.get('password') # # } # } # } requests.post(url, json=json) return Response(serializer_class.data, status=status.HTTP_200_OK)
def task_list(request): ''' List all tasks, or create a new task. ''' if request.method == 'GET': tasks = Task.objects.all() serializer = TaskSerializer(tasks, many=True) return Response(serializer.data) elif request.method == 'POST': serializer = TaskSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def retrieve(self, request, pk): print(request.user) if request.user.is_anonymous: return http.HttpResponseForbidden() try: task = Task.objects.get(id=pk) except Task.DoesNotExist: return http.HttpResponseNotFound() data = TaskSerializer(task).data data['solutions'] = [ sol for sol in data['solutions'] if sol['author'] == request.user.id ] return http.JsonResponse(data)