feat: add POST /v1/tasks endpoint with validation and transaction support (#21)

* changes to Task Model for default values

* feat: Create Tasks

* Added extra validation and error handling

* fixed null fields being ignored in response

* feat(docker): enable MongoDB replica set with auto-init for transactions

* refactor: code refactor according to coderabbit's review

* fix: displayId as per existing notation and uniqueness through indexing

* fix: failing tests due to required field

* feat(task): standardize create task error responses using ApiErrorResponse

* refactor: implement atomic counter for task displayId generation

* fix lint and format issues

* fix: accessing private method

* chore(refactor): moved messages to constants

* Tests for the Create tasks API (#24)

* tests: Unit tests for create tasks functionality

* fix: accessing private method

* chore(refactor): moved messages to constants

* chore(refactor): tests according to latest changes and format

Author: VaibhavSingh8

docker-compose.yml

@@ -21,4 +21,19 @@ services:
     ports:
       - "27017:27017"
     volumes:
-      - ./mongo_data:/data/db
+      - ./mongo_data:/data/db
+    healthcheck:
+      test: ["CMD", "mongosh", "--eval", "'db.runCommand({ping:1})'"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 15s
+
+    #to enable replica set, requirement for enabling transactions
+    command: >
+      sh -c "
+        mongod --replSet rs0 --bind_ip_all --logpath /var/log/mongodb.log --logappend &
+        sleep 5 &&
+        mongosh --eval 'try { rs.initiate() } catch(e) { print(e) }' &&
+        tail -f /var/log/mongodb.log
+      "

todo/apps.py

@@ -1,5 +1,24 @@
 from django.apps import AppConfig
+import logging
+from todo.constants.messages import RepositoryErrors
+import sys
+
+logger = logging.getLogger(__name__)
 
 
 class TodoConfig(AppConfig):
     name = "todo"
+
+    def ready(self):
+        """Initialize application components when Django starts"""
+
+        if "test" in sys.argv:
+            logger.info("Test mode detected - skipping database initialization")
+            return
+
+        from todo_project.db.init import initialize_database
+
+        try:
+            initialize_database()
+        except Exception as e:
+            logger.error(RepositoryErrors.DB_INIT_FAILED.format(str(e)))

todo/constants/messages.py

@@ -0,0 +1,30 @@
+# Application Messages
+class AppMessages:
+    TASK_CREATED = "Task created successfully"
+    
+# Repository error messages
+class RepositoryErrors:
+    TASK_CREATION_FAILED = "Failed to create task: {0}"
+    DB_INIT_FAILED = "Failed to initialize database: {0}"
+
+# API error messages
+class ApiErrors:
+    REPOSITORY_ERROR = "Repository Error"
+    SERVER_ERROR = "Server Error"
+    UNEXPECTED_ERROR = "Unexpected Error"
+    INTERNAL_SERVER_ERROR = "Internal server error"
+    VALIDATION_ERROR = "Validation Error"
+    INVALID_LABELS = "Invalid Labels"
+    INVALID_LABEL_IDS = "Invalid Label IDs"
+    PAGE_NOT_FOUND = "Requested page exceeds available results"
+    UNEXPECTED_ERROR_OCCURRED = "An unexpected error occurred"
+
+# Validation error messages
+class ValidationErrors:
+    BLANK_TITLE = "Title must not be blank."
+    INVALID_OBJECT_ID = "{0} is not a valid ObjectId."
+    PAST_DUE_DATE = "Due date must be in the future."
+    PAGE_POSITIVE = "Page must be a positive integer"
+    LIMIT_POSITIVE = "Limit must be a positive integer"
+    MAX_LIMIT_EXCEEDED = "Maximum limit of {0} exceeded"
+    MISSING_LABEL_IDS = "The following label IDs do not exist: {0}"

todo/dto/responses/create_task_response.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+from todo.dto.task_dto import TaskDTO
+from todo.constants.messages import AppMessages
+
+class CreateTaskResponse(BaseModel):
+    statusCode: int = 201
+    successMessage: str = AppMessages.TASK_CREATED
+    data: TaskDTO

todo/dto/task_dto.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from typing import List
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
 
 from todo.constants.task import TaskPriority, TaskStatus
 from todo.dto.label_dto import LabelDTO
@@ -26,3 +26,25 @@ class TaskDTO(BaseModel):
 
     class Config:
         json_encoders = {TaskPriority: lambda x: x.name}
+
+
+class CreateTaskDTO(BaseModel):
+    title: str
+    description: str | None = None
+    priority: TaskPriority = TaskPriority.LOW
+    status: TaskStatus = TaskStatus.TODO
+    assignee: str | None = None
+    labels: List[str] = []
+    dueAt: datetime | None = None
+
+    @field_validator("priority", mode="before")
+    def parse_priority(cls, value):
+        if isinstance(value, str):
+            return TaskPriority[value]
+        return value
+
+    @field_validator("status", mode="before")
+    def parse_status(cls, value):
+        if isinstance(value, str):
+            return TaskStatus[value]
+        return value

todo/models/task.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ConfigDict
 from typing import ClassVar, List
 from datetime import datetime
 
@@ -24,13 +24,13 @@ class TaskModel(Document):
     collection_name: ClassVar[str] = "tasks"
 
     id: PyObjectId | None = Field(None, alias="_id")
-    displayId: str
+    displayId: str | None = None
     title: str
     description: str | None = None
-    priority: TaskPriority | None = None
-    status: TaskStatus | None = None
+    priority: TaskPriority | None = TaskPriority.LOW
+    status: TaskStatus | None = TaskStatus.TODO
     assignee: str | None = None
-    isAcknowledged: bool | None = None
+    isAcknowledged: bool = False
     labels: List[PyObjectId] | None = []
     isDeleted: bool = False
     deferredDetails: DeferredDetailsModel | None = None
@@ -40,3 +40,5 @@ class TaskModel(Document):
     updatedAt: datetime | None = None
     createdBy: str
     updatedBy: str | None = None
+
+    model_config = ConfigDict(ser_enum="value")

todo/repositories/common/mongo_repository.py

@@ -18,3 +18,11 @@ def get_collection(cls):
         if cls.collection is None:
             cls.collection = cls.database_manager.get_collection(cls.collection_name)
         return cls.collection
+
+    @classmethod
+    def get_client(cls):
+        return cls.database_manager._get_database_client()
+
+    @classmethod
+    def get_database(cls):
+        return cls.database_manager.get_database()

todo/repositories/task_repository.py

@@ -1,6 +1,9 @@
+from datetime import datetime, timezone
 from typing import List
+
 from todo.models.task import TaskModel
 from todo.repositories.common.mongo_repository import MongoRepository
+from todo.constants.messages import RepositoryErrors
 
 
 class TaskRepository(MongoRepository):
@@ -28,3 +31,45 @@ def get_all(cls) -> List[TaskModel]:
         tasks_collection = cls.get_collection()
         tasks_cursor = tasks_collection.find()
         return [TaskModel(**task) for task in tasks_cursor]
+
+    @classmethod
+    def create(cls, task: TaskModel) -> TaskModel:
+        """
+        Creates a new task in the repository with a unique displayId, using atomic counter operations.
+
+        Args:
+            task (TaskModel): Task to create
+
+        Returns:
+            TaskModel: Created task with displayId
+        """
+        tasks_collection = cls.get_collection()
+        client = cls.get_client()
+
+        with client.start_session() as session:
+            try:
+                with session.start_transaction():
+                    # Atomically increment and get the next counter value
+                    db = cls.get_database()
+                    counter_result = db.counters.find_one_and_update(
+                        {"_id": "taskDisplayId"}, {"$inc": {"seq": 1}}, return_document=True, session=session
+                    )
+
+                    if not counter_result:
+                        db.counters.insert_one({"_id": "taskDisplayId", "seq": 1}, session=session)
+                        next_number = 1
+                    else:
+                        next_number = counter_result["seq"]
+
+                    task.displayId = f"#{next_number}"
+                    task.createdAt = datetime.now(timezone.utc)
+                    task.updatedAt = None
+
+                    task_dict = task.model_dump(mode="json", by_alias=True, exclude_none=True)
+                    insert_result = tasks_collection.insert_one(task_dict, session=session)
+
+                    task.id = insert_result.inserted_id
+                    return task
+
+            except Exception as e:
+                raise ValueError(RepositoryErrors.TASK_CREATION_FAILED.format(str(e)))

todo/serializers/create_task_serializer.py

@@ -0,0 +1,50 @@
+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 CreateTaskSerializer(serializers.Serializer):
+    title = serializers.CharField(required=True, allow_blank=False)
+    description = serializers.CharField(required=False, allow_blank=True, allow_null=True)
+    priority = serializers.ChoiceField(
+        required=False,
+        choices=[priority.name for priority in TaskPriority],
+        default=TaskPriority.LOW.name,
+    )
+    status = serializers.ChoiceField(
+        required=False,
+        choices=[status.name for status in TaskStatus],
+        default=TaskStatus.TODO.name,
+    )
+    assignee = serializers.CharField(required=False, allow_blank=True, allow_null=True)
+    labels = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        default=list,
+    )
+    dueAt = serializers.DateTimeField(required=False, allow_null=True)
+
+    def validate_title(self, value):
+        if not value.strip():
+            raise serializers.ValidationError(ValidationErrors.BLANK_TITLE)
+        return value
+
+    def validate_labels(self, value):
+        for label_id in value:
+            if not ObjectId.is_valid(label_id):
+                raise serializers.ValidationError(ValidationErrors.INVALID_OBJECT_ID.format(label_id))
+        return value
+
+    def validate_dueAt(self, value):
+        if value is not None:
+            now = datetime.now(timezone.utc)
+            if value <= now:
+                raise serializers.ValidationError(ValidationErrors.PAST_DUE_DATE)
+        return value
+
+    def validate_assignee(self, value):
+        if isinstance(value, str) and not value.strip():
+            return None
+        return value

todo/services/task_service.py

@@ -4,15 +4,20 @@
 from django.core.exceptions import ValidationError
 from django.urls import reverse_lazy
 from urllib.parse import urlencode
+from datetime import datetime, timezone
 
 from todo.dto.label_dto import LabelDTO
-from todo.dto.task_dto import TaskDTO
+from todo.dto.task_dto import TaskDTO, CreateTaskDTO
 from todo.dto.user_dto import UserDTO
 from todo.dto.responses.get_tasks_response import GetTasksResponse
+from todo.dto.responses.create_task_response import CreateTaskResponse
+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.repositories.task_repository import TaskRepository
 from todo.repositories.label_repository import LabelRepository
+from todo.constants.task import TaskStatus
+from todo.constants.messages import ApiErrors, ValidationErrors
 from django.conf import settings
 
 
@@ -141,3 +146,78 @@ def _prepare_label_dtos(cls, label_ids: List[str]) -> List[LabelDTO]:
     @classmethod
     def prepare_user_dto(cls, user_id: str) -> UserDTO:
         return UserDTO(id=user_id, name="SYSTEM")
+
+    @classmethod
+    def create_task(cls, dto: CreateTaskDTO) -> CreateTaskResponse:
+        now = datetime.now(timezone.utc)
+        started_at = now if dto.status == TaskStatus.IN_PROGRESS else None
+
+        if dto.labels:
+            existing_labels = LabelRepository.list_by_ids(dto.labels)
+            if len(existing_labels) != len(dto.labels):
+                found_ids = [str(label.id) for label in existing_labels]
+                missing_ids = [label_id for label_id in dto.labels if label_id not in found_ids]
+
+                raise ValueError(
+                    ApiErrorResponse(
+                        statusCode=400,
+                        message=ApiErrors.INVALID_LABELS,
+                        errors=[
+                            ApiErrorDetail(
+                                source={ApiErrorSource.PARAMETER: "labels"},
+                                title=ApiErrors.INVALID_LABEL_IDS,
+                                detail=ValidationErrors.MISSING_LABEL_IDS.format(", ".join(missing_ids)),
+                            )
+                        ],
+                    )
+                )
+
+        task = TaskModel(
+            title=dto.title,
+            description=dto.description,
+            priority=dto.priority,
+            status=dto.status,
+            assignee=dto.assignee,
+            labels=dto.labels,
+            dueAt=dto.dueAt,
+            startedAt=started_at,
+            createdAt=now,
+            isAcknowledged=False,
+            isDeleted=False,
+            createdBy="system",  # placeholder, will be user_id when auth is in place
+        )
+
+        try:
+            created_task = TaskRepository.create(task)
+            task_dto = cls.prepare_task_dto(created_task)
+            return CreateTaskResponse(data=task_dto)
+        except ValueError as e:
+            if isinstance(e.args[0], ApiErrorResponse):
+                raise e
+            raise ValueError(
+                ApiErrorResponse(
+                    statusCode=500,
+                    message=ApiErrors.REPOSITORY_ERROR,
+                    errors=[
+                        ApiErrorDetail(
+                            source={ApiErrorSource.PARAMETER: "task_repository"},
+                            title=ApiErrors.UNEXPECTED_ERROR,
+                            detail=str(e) if settings.DEBUG else ApiErrors.INTERNAL_SERVER_ERROR,
+                        )
+                    ],
+                )
+            )
+        except Exception as e:
+            raise ValueError(
+                ApiErrorResponse(
+                    statusCode=500,
+                    message=ApiErrors.SERVER_ERROR,
+                    errors=[
+                        ApiErrorDetail(
+                            source={ApiErrorSource.PARAMETER: "server"},
+                            title=ApiErrors.UNEXPECTED_ERROR,
+                            detail=str(e) if settings.DEBUG else ApiErrors.INTERNAL_SERVER_ERROR,
+                        )
+                    ],
+                )
+            )