feature: implement business task intake flow

Author: plainOldCode

README.md

@@ -41,16 +41,17 @@ The current codebase proves the delivery path with a small working slice:
 
 - `GET /api/health`
 - `GET /api/tasks`
-- Vue rendering of live backend health and seeded MariaDB task rows
-- Playwright smoke coverage for API health, API task reads, and the home page
+- `POST /api/tasks` with validated business planning fields
+- Vue rendering of live backend health, business-task intake, and planning-oriented task rows
+- Playwright smoke coverage for API health, API task reads, API task creation, and UI create/read paths
 - Local Docker and `k3d` validation through the Helm chart
 
 ## Documented Next Feature
 
 The task lifecycle package under `docs/` is intentionally the next planned implementation step, not a claim that it already exists in code.
 
-- task creation via `POST /api/tasks`
 - constrained status transitions via `PATCH /api/tasks/{id}`
+- lifecycle rules layered on top of the existing task intake flow
 - `blockedReason` validation and UI treatment
 - richer task lifecycle e2e scenarios
 - Liquibase schema expansion for `blocked_reason` and `updated_at`
@@ -129,8 +130,8 @@ The supporting note for that workflow lives in [`docs/ai-workflow.md`](docs/ai-w
 
 Current documentation examples:
 
+- Implemented business-task slice: [`docs/prd/business-task-intake-and-planning.md`](docs/prd/business-task-intake-and-planning.md) and [`docs/spec/business-task-intake-and-planning.md`](docs/spec/business-task-intake-and-planning.md)
 - Planned implementation slice: [`docs/prd/task-lifecycle-and-status-rules.md`](docs/prd/task-lifecycle-and-status-rules.md) and [`docs/spec/task-lifecycle-and-status-rules.md`](docs/spec/task-lifecycle-and-status-rules.md)
-- PRD-stage business planning slice: [`docs/prd/business-task-intake-and-planning.md`](docs/prd/business-task-intake-and-planning.md)
 
 ## Workspace Shape
 

backend/src/main/kotlin/com/example/demo/SampleTaskController.kt

@@ -1,9 +1,21 @@
 package com.example.demo
 
+import jakarta.validation.Valid
+import jakarta.validation.constraints.NotBlank
+import jakarta.validation.constraints.NotNull
+import jakarta.validation.constraints.Size
+import org.springframework.http.HttpStatus
 import org.springframework.jdbc.core.simple.JdbcClient
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
+import org.springframework.jdbc.support.GeneratedKeyHolder
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.ResponseStatus
 import org.springframework.web.bind.annotation.RestController
+import java.time.LocalDate
 
 @RestController
 @RequestMapping("/api/tasks")
@@ -13,34 +25,130 @@ class SampleTaskController(
 
     @GetMapping
     fun listTasks(): List<SampleTaskResponse> = sampleTaskService.findAll()
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    fun createTask(@Valid @RequestBody request: CreateBusinessTaskRequest): SampleTaskResponse {
+        return sampleTaskService.createTask(request)
+    }
 }
 
 @org.springframework.stereotype.Service
 class SampleTaskService(
-    private val jdbcClient: JdbcClient
+    private val jdbcClient: JdbcClient,
+    private val namedParameterJdbcTemplate: NamedParameterJdbcTemplate
 ) {
 
     fun findAll(): List<SampleTaskResponse> {
         return jdbcClient.sql(
             """
-            SELECT id, title, status, created_at
+            SELECT id, title, status, created_at, customer_request, requested_work,
+                   target_delivery_date, build_estimate, owner_name
             FROM sample_task
             ORDER BY id
             """.trimIndent()
-        ).query { rs, _ ->
-            SampleTaskResponse(
-                id = rs.getLong("id"),
-                title = rs.getString("title"),
-                status = rs.getString("status"),
-                createdAt = rs.getTimestamp("created_at").toInstant().toString()
+        ).query(::mapTask).list()
+    }
+
+    fun createTask(request: CreateBusinessTaskRequest): SampleTaskResponse {
+        val normalizedRequestedWork = request.requestedWork.requireText()
+        val keyHolder = GeneratedKeyHolder()
+
+        namedParameterJdbcTemplate.update(
+            """
+            INSERT INTO sample_task (
+              title,
+              status,
+              customer_request,
+              requested_work,
+              target_delivery_date,
+              build_estimate,
+              owner_name
+            ) VALUES (
+              :title,
+              :status,
+              :customerRequest,
+              :requestedWork,
+              :targetDeliveryDate,
+              :buildEstimate,
+              :ownerName
             )
-        }.list()
+            """.trimIndent(),
+            MapSqlParameterSource()
+                .addValue("title", toTitle(normalizedRequestedWork))
+                .addValue("status", "TODO")
+                .addValue("customerRequest", request.customerRequest.requireText())
+                .addValue("requestedWork", normalizedRequestedWork)
+                .addValue("targetDeliveryDate", requireNotNull(request.targetDeliveryDate))
+                .addValue("buildEstimate", request.buildEstimate.requireText())
+                .addValue("ownerName", request.owner.requireText()),
+            keyHolder,
+            arrayOf("id")
+        )
+
+        val taskId = keyHolder.key?.toLong() ?: error("Task insert did not return an ID")
+        return findById(taskId) ?: error("Task $taskId was created but could not be read back")
+    }
+
+    private fun findById(id: Long): SampleTaskResponse? {
+        return jdbcClient.sql(
+            """
+            SELECT id, title, status, created_at, customer_request, requested_work,
+                   target_delivery_date, build_estimate, owner_name
+            FROM sample_task
+            WHERE id = :id
+            """.trimIndent()
+        ).param("id", id).query(::mapTask).optional().orElse(null)
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    private fun mapTask(rs: java.sql.ResultSet, rowNumber: Int): SampleTaskResponse {
+        return SampleTaskResponse(
+            id = rs.getLong("id"),
+            title = rs.getString("title"),
+            status = rs.getString("status"),
+            createdAt = rs.getTimestamp("created_at").toInstant().toString(),
+            customerRequest = rs.getString("customer_request"),
+            requestedWork = rs.getString("requested_work"),
+            targetDeliveryDate = rs.getDate("target_delivery_date").toLocalDate().toString(),
+            buildEstimate = rs.getString("build_estimate"),
+            owner = rs.getString("owner_name")
+        )
+    }
+
+    private fun toTitle(requestedWork: String): String {
+        val compact = requestedWork.replace("\\s+".toRegex(), " ").trim()
+        return if (compact.length <= 100) compact else compact.take(97).trimEnd() + "..."
     }
 }
 
+data class CreateBusinessTaskRequest(
+    @field:NotBlank(message = "Customer request is required")
+    @field:Size(max = 255, message = "Customer request must be 255 characters or fewer")
+    val customerRequest: String?,
+    @field:NotBlank(message = "Requested work is required")
+    @field:Size(max = 255, message = "Requested work must be 255 characters or fewer")
+    val requestedWork: String?,
+    @field:NotNull(message = "Delivery date is required")
+    val targetDeliveryDate: LocalDate?,
+    @field:NotBlank(message = "Build estimate is required")
+    @field:Size(max = 60, message = "Build estimate must be 60 characters or fewer")
+    val buildEstimate: String?,
+    @field:NotBlank(message = "Owner is required")
+    @field:Size(max = 80, message = "Owner must be 80 characters or fewer")
+    val owner: String?
+)
+
 data class SampleTaskResponse(
     val id: Long,
     val title: String,
     val status: String,
-    val createdAt: String
+    val createdAt: String,
+    val customerRequest: String,
+    val requestedWork: String,
+    val targetDeliveryDate: String,
+    val buildEstimate: String,
+    val owner: String
 )
+
+private fun String?.requireText(): String = requireNotNull(this).trim()

backend/src/main/kotlin/com/example/demo/TaskApiExceptionHandler.kt

@@ -0,0 +1,40 @@
+package com.example.demo
+
+import org.springframework.http.HttpStatus
+import org.springframework.http.converter.HttpMessageNotReadableException
+import org.springframework.web.bind.MethodArgumentNotValidException
+import org.springframework.web.bind.annotation.ExceptionHandler
+import org.springframework.web.bind.annotation.ResponseStatus
+import org.springframework.web.bind.annotation.RestControllerAdvice
+
+@RestControllerAdvice
+class TaskApiExceptionHandler {
+
+    @ExceptionHandler(MethodArgumentNotValidException::class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    fun handleValidationFailure(exception: MethodArgumentNotValidException): TaskApiErrorResponse {
+        return TaskApiErrorResponse(
+            code = "VALIDATION_ERROR",
+            message = "Task input is invalid",
+            fieldErrors = exception.bindingResult.fieldErrors.associate { fieldError ->
+                fieldError.field to (fieldError.defaultMessage ?: "Invalid value")
+            }
+        )
+    }
+
+    @ExceptionHandler(HttpMessageNotReadableException::class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    fun handleUnreadableBody(): TaskApiErrorResponse {
+        return TaskApiErrorResponse(
+            code = "INVALID_REQUEST",
+            message = "Request body could not be read",
+            fieldErrors = emptyMap()
+        )
+    }
+}
+
+data class TaskApiErrorResponse(
+    val code: String,
+    val message: String,
+    val fieldErrors: Map<String, String>
+)

backend/src/main/resources/db/liquibase/changelog/changes/0002-business-task-planning.yaml

@@ -0,0 +1,79 @@
+databaseChangeLog:
+  - changeSet:
+      id: 0003-add-business-task-planning-columns
+      author: codex
+      preConditions:
+        - onFail: MARK_RAN
+        - not:
+            - columnExists:
+                tableName: sample_task
+                columnName: customer_request
+      changes:
+        - addColumn:
+            tableName: sample_task
+            columns:
+              - column:
+                  name: customer_request
+                  type: varchar(255)
+              - column:
+                  name: requested_work
+                  type: varchar(255)
+              - column:
+                  name: target_delivery_date
+                  type: date
+              - column:
+                  name: build_estimate
+                  type: varchar(60)
+              - column:
+                  name: owner_name
+                  type: varchar(80)
+        - sql:
+            sql: |
+              UPDATE sample_task
+              SET
+                customer_request = CASE
+                  WHEN title = 'Wire backend to frontend' THEN 'Frontend review needs live task data from the backend'
+                  WHEN title = 'Prepare k3s test namespace' THEN 'Platform review needs a reusable QA namespace check'
+                  ELSE 'Internal delivery planning request'
+                END,
+                requested_work = CASE
+                  WHEN title = 'Wire backend to frontend' THEN 'Connect the Vue task board to backend task APIs'
+                  WHEN title = 'Prepare k3s test namespace' THEN 'Prepare a k3s namespace smoke path for PR environments'
+                  ELSE title
+                END,
+                target_delivery_date = CASE
+                  WHEN title = 'Wire backend to frontend' THEN '2026-03-28'
+                  WHEN title = 'Prepare k3s test namespace' THEN '2026-03-25'
+                  ELSE '2026-03-31'
+                END,
+                build_estimate = CASE
+                  WHEN title = 'Wire backend to frontend' THEN '2 engineering days'
+                  WHEN title = 'Prepare k3s test namespace' THEN '1 engineering day'
+                  ELSE 'TBD'
+                END,
+                owner_name = 'Sky'
+              WHERE customer_request IS NULL
+                 OR requested_work IS NULL
+                 OR target_delivery_date IS NULL
+                 OR build_estimate IS NULL
+                 OR owner_name IS NULL;
+        - addNotNullConstraint:
+            tableName: sample_task
+            columnName: customer_request
+            columnDataType: varchar(255)
+        - addNotNullConstraint:
+            tableName: sample_task
+            columnName: requested_work
+            columnDataType: varchar(255)
+        - addNotNullConstraint:
+            tableName: sample_task
+            columnName: target_delivery_date
+            columnDataType: date
+        - addNotNullConstraint:
+            tableName: sample_task
+            columnName: build_estimate
+            columnDataType: varchar(60)
+        - addNotNullConstraint:
+            tableName: sample_task
+            columnName: owner_name
+            columnDataType: varchar(80)

backend/src/main/resources/db/liquibase/changelog/db.changelog-master.yaml

@@ -1,3 +1,5 @@
 databaseChangeLog:
   - include:
       file: db/liquibase/changelog/changes/0001-init.yaml
+  - include:
+      file: db/liquibase/changelog/changes/0002-business-task-planning.yaml