Feat: API endpoint for partially updating a task's details using PATCH /tasks/{task_id}/ (#52)

* feat: Implement PATCH /tasks/{task_id} to update tasks
- Added  method to handle update requests.
- Introduced  for validating incoming update data,
  ensuring all fields are optional and  is a future date.
- Added  method to  to perform the MongoDB
   operation, ensuring  is set.
- Implemented  to orchestrate the update logic:
    - Fetches the task or raises .
    - Processes validated data from the serializer.
    - Converts label string IDs to  and validates their existence.
    - Converts priority and status string names to their enum values for
      database storage.
    - Sets  (currently placeholder).
    - Calls the repository to persist changes.
- Corrected an issue where enum objects (Priority, Status) were passed
  directly to the database layer, causing a serialization error. Now,
  their primitive values are stored.
- Refined  construction in  to ensure
  all valid fields from the serializer are correctly prepared for update.

* refactor(tasks): Standardize error handling in TaskService update

- Removes redundant format validation for label ObjectIds, as this is
  already handled by .
- For missing (but validly formatted) label IDs,
  now raises  instead of a
  custom

* rfactor:  PATCH /tasks/{task_id} endpoint to have task title blank true

* refactor: improve error handling for task updates and ID validation

centralizes error handling for task update operations:

- Removes specific ObjectId validation from . Invalid ID formats will now correctly raise , which is handled by the global DRF exception handler to return a 400 Bad Request.
- Modifies  to raise  if the task to be updated is not found. This is also handled by the global exception handler, resulting in a 404 Not Found response

* refactor: Enhance serializer validations and repository clarity
    - Implemented validation to ensure `startedAt` cannot be a future date.
    - Added `FUTURE_STARTED_AT` to `ValidationErrors` in `constants/messages.py`
      for the new validation message.
    - Added an explicit type check to ensure `labels` input is a list or tuple.
    - Modified to collect all invalid ObjectId formats within the `labels` list
      and report them in a single `ValidationError` for better client feedback.
    - Moved the "Labels must be a list or tuple..." message to
      `ValidationErrors.INVALID_LABELS_STRUCTURE` in `constants/messages.py`
      and updated the serializer to use this constant.
    - Deleted an unreachable `if not update_data_with_timestamp: pass` block,
      as the updatedAt field ensures the dictionary is never empty at that point.

* Update todo/serializers/update_task_serializer.py

Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

* Update todo/views/task.py

Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

* fix: gramatical errors on the constants

* fix: added missing imports

* fix: used global exception handler for catching errors

* Refactor(TaskRepository): modify update method for input validation and ObjectId handling

* refactor(serializers): align validate_dueAt error handling pattern

-refactors the  method in
to collect validation errors in a list and raise a single
 with this list.

* refactor(services): reduce complexity of TaskService.update_task

-Refactors the  method in  to improve
readability and reduce cognitive complexity. The core logic for
processing specific field types (labels, enums) has been extracted
into dedicated helper methods:  and

* refactor(services): reduce complexity of TaskService.update_task

-Refactors the  method in  to improve
readability and reduce cognitive complexity. The core logic for
processing specific field types (labels, enums) has been extracted
into dedicated helper methods:  and

* refactor: refactor the code to improve maintainability

---------

Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

Author: Achintya-Chatterjee

todo/constants/messages.py

@@ -35,3 +35,5 @@ class ValidationErrors:
     MAX_LIMIT_EXCEEDED = "Maximum limit of {0} exceeded"
     MISSING_LABEL_IDS = "The following label ID(s) do not exist: {0}."
     INVALID_TASK_ID_FORMAT = "Please enter a valid Task ID format."
+    FUTURE_STARTED_AT = "The start date cannot be set in the future."
+    INVALID_LABELS_STRUCTURE = "Labels must be provided as a list or tuple of ObjectId strings."

todo/repositories/task_repository.py

@@ -103,3 +103,30 @@ def delete_by_id(cls, task_id: str) -> TaskModel | None:
         if deleted_task_data:
             return TaskModel(**deleted_task_data)
         return None
+
+    @classmethod
+    def update(cls, task_id: str, update_data: dict) -> TaskModel | None:
+        """
+        Updates a specific task by its ID with the given data.
+        """
+        if not isinstance(update_data, dict):
+            raise ValueError("update_data must be a dictionary.")
+
+        try:
+            obj_id = ObjectId(task_id)
+        except Exception:
+            return None
+
+        update_data_with_timestamp = {**update_data, "updatedAt": datetime.now(timezone.utc)}
+        update_data_with_timestamp.pop("_id", None)
+        update_data_with_timestamp.pop("id", None)
+
+        tasks_collection = cls.get_collection()
+
+        updated_task_doc = tasks_collection.find_one_and_update(
+            {"_id": obj_id}, {"$set": update_data_with_timestamp}, return_document=ReturnDocument.AFTER
+        )
+
+        if updated_task_doc:
+            return TaskModel(**updated_task_doc)
+        return None

todo/serializers/update_task_serializer.py

@@ -0,0 +1,71 @@
+from rest_framework import serializers
+from bson import ObjectId
+from datetime import datetime, timezone
+
+from todo.constants.task import TaskPriority, TaskStatus
+from todo.constants.messages import ValidationErrors
+
+
+class UpdateTaskSerializer(serializers.Serializer):
+    title = serializers.CharField(required=False, allow_blank=True, max_length=255)
+    description = serializers.CharField(required=False, allow_blank=True, allow_null=True)
+    priority = serializers.ChoiceField(
+        required=False,
+        choices=[priority.name for priority in TaskPriority],
+        allow_null=True,
+    )
+    status = serializers.ChoiceField(
+        required=False,
+        choices=[status.name for status in TaskStatus],
+        allow_null=True,
+    )
+    assignee = serializers.CharField(required=False, allow_blank=True, allow_null=True)
+    labels = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        allow_null=True,
+    )
+    dueAt = serializers.DateTimeField(required=False, allow_null=True)
+    startedAt = serializers.DateTimeField(required=False, allow_null=True)
+    isAcknowledged = serializers.BooleanField(required=False)
+
+    def validate_title(self, value):
+        if value is not None and not value.strip():
+            raise serializers.ValidationError(ValidationErrors.BLANK_TITLE)
+        return value
+
+    def validate_labels(self, value):
+        if value is None:
+            return value
+
+        if not isinstance(value, (list, tuple)):
+            raise serializers.ValidationError(ValidationErrors.INVALID_LABELS_STRUCTURE)
+
+        invalid_ids = [label_id for label_id in value if not ObjectId.is_valid(label_id)]
+        if invalid_ids:
+            raise serializers.ValidationError(
+                [ValidationErrors.INVALID_OBJECT_ID.format(label_id) for label_id in invalid_ids]
+            )
+
+        return value
+
+    def validate_dueAt(self, value):
+        if value is None:
+            return value
+        errors = []
+        now = datetime.now(timezone.utc)
+        if value <= now:
+            errors.append(ValidationErrors.PAST_DUE_DATE)
+        if errors:
+            raise serializers.ValidationError(errors)
+        return value
+
+    def validate_startedAt(self, value):
+        if value and value > datetime.now(timezone.utc):
+            raise serializers.ValidationError(ValidationErrors.FUTURE_STARTED_AT)
+        return value
+
+    def validate_assignee(self, value):
+        if isinstance(value, str) and not value.strip():
+            return None
+        return value

todo/services/task_service.py

@@ -5,6 +5,7 @@
 from django.urls import reverse_lazy
 from urllib.parse import urlencode
 from datetime import datetime, timezone
+from rest_framework.exceptions import ValidationError as DRFValidationError
 from todo.dto.label_dto import LabelDTO
 from todo.dto.task_dto import TaskDTO, CreateTaskDTO
 from todo.dto.user_dto import UserDTO
@@ -13,9 +14,10 @@
 from todo.dto.responses.error_response import ApiErrorResponse, ApiErrorDetail, ApiErrorSource
 from todo.dto.responses.paginated_response import LinksData
 from todo.models.task import TaskModel
+from todo.models.common.pyobjectid import PyObjectId
 from todo.repositories.task_repository import TaskRepository
 from todo.repositories.label_repository import LabelRepository
-from todo.constants.task import TaskStatus
+from todo.constants.task import TaskStatus, TaskPriority
 from todo.constants.messages import ApiErrors, ValidationErrors
 from django.conf import settings
 from todo.exceptions.task_exceptions import TaskNotFoundException
@@ -30,6 +32,8 @@ class PaginationConfig:
 
 
 class TaskService:
+    DIRECT_ASSIGNMENT_FIELDS = {"title", "description", "assignee", "dueAt", "startedAt", "isAcknowledged"}
+
     @classmethod
     def get_tasks(
         cls, page: int = PaginationConfig.DEFAULT_PAGE, limit: int = PaginationConfig.DEFAULT_LIMIT
@@ -158,6 +162,57 @@ def get_task_by_id(cls, task_id: str) -> TaskDTO:
         except BsonInvalidId as exc:
             raise exc
 
+    @classmethod
+    def _process_labels_for_update(cls, raw_labels: list | None) -> list[PyObjectId]:
+        if raw_labels is None:
+            return []
+
+        label_object_ids = [PyObjectId(label_id_str) for label_id_str in raw_labels]
+
+        if label_object_ids:
+            existing_labels = LabelRepository.list_by_ids(label_object_ids)
+            if len(existing_labels) != len(label_object_ids):
+                found_db_ids_str = {str(label.id) for label in existing_labels}
+                missing_ids_str = [str(py_id) for py_id in label_object_ids if str(py_id) not in found_db_ids_str]
+                raise DRFValidationError(
+                    {"labels": [ValidationErrors.MISSING_LABEL_IDS.format(", ".join(missing_ids_str))]}
+                )
+        return label_object_ids
+
+    @classmethod
+    def _process_enum_for_update(cls, enum_type: type, value: str | None) -> str | None:
+        if value is None:
+            return None
+        return enum_type[value].value
+
+    @classmethod
+    def update_task(cls, task_id: str, validated_data: dict, user_id: str = "system") -> TaskDTO:
+        current_task = TaskRepository.get_by_id(task_id)
+        if not current_task:
+            raise TaskNotFoundException(task_id)
+
+        update_payload = {}
+        enum_fields = {"priority": TaskPriority, "status": TaskStatus}
+
+        for field, value in validated_data.items():
+            if field == "labels":
+                update_payload[field] = cls._process_labels_for_update(value)
+            elif field in enum_fields:
+                update_payload[field] = cls._process_enum_for_update(enum_fields[field], value)
+            elif field in cls.DIRECT_ASSIGNMENT_FIELDS:
+                update_payload[field] = value
+
+        if not update_payload:
+            return cls.prepare_task_dto(current_task)
+
+        update_payload["updatedBy"] = user_id
+        updated_task = TaskRepository.update(task_id, update_payload)
+
+        if not updated_task:
+            raise TaskNotFoundException(task_id)
+
+        return cls.prepare_task_dto(updated_task)
+
     @classmethod
     def create_task(cls, dto: CreateTaskDTO) -> CreateTaskResponse:
         now = datetime.now(timezone.utc)

todo/tests/integration/test_tasks_delete.py

@@ -6,6 +6,7 @@
 from todo.constants.messages import ApiErrors
 from todo.tests.fixtures.task import task_dtos
 
+
 class TaskDeleteAPIIntegrationTest(APITestCase):
     def setUp(self):
         self.task_id = task_dtos[0].id

todo/tests/unit/repositories/test_task_repository.py

@@ -247,4 +247,4 @@ def test_delete_task_returns_none_when_already_deleted(self, mock_get_collection
         mock_collection.find_one_and_update.return_value = None
 
         result = TaskRepository.delete_by_id(self.task_id)
-        self.assertIsNone(result)
+        self.assertIsNone(result)

todo/tests/unit/views/test_task.py

@@ -19,6 +19,7 @@
 from todo.exceptions.task_exceptions import TaskNotFoundException
 from todo.constants.messages import ValidationErrors, ApiErrors
 
+
 class TaskViewTests(APISimpleTestCase):
     def setUp(self):
         self.client = APIClient()

todo/views/task.py

@@ -6,6 +6,7 @@
 from django.conf import settings
 from todo.serializers.get_tasks_serializer import GetTaskQueryParamsSerializer
 from todo.serializers.create_task_serializer import CreateTaskSerializer
+from todo.serializers.update_task_serializer import UpdateTaskSerializer
 from todo.services.task_service import TaskService
 from todo.dto.task_dto import CreateTaskDTO
 from todo.dto.responses.create_task_response import CreateTaskResponse
@@ -97,3 +98,19 @@ def delete(self, request: Request, task_id: str):
         task_id = ObjectId(task_id)
         TaskService.delete_task(task_id)
         return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def patch(self, request: Request, task_id: str):
+        """
+        Partially updates a task by its ID.
+
+        """
+        serializer = UpdateTaskSerializer(data=request.data, partial=True)
+        serializer.is_valid(raise_exception=True)
+        # This is a placeholder for the user ID, NEED TO IMPLEMENT THIS AFTER AUTHENTICATION
+        user_id_placeholder = "system_patch_user"
+
+        updated_task_dto = TaskService.update_task(
+            task_id=(task_id), validated_data=serializer.validated_data, user_id=user_id_placeholder
+        )
+
+        return Response(data=updated_task_dto.model_dump(mode="json", exclude_none=True), status=status.HTTP_200_OK)