Files
kandev/apps/backend/internal/task/service/plan_service.go
T
2026-02-26 13:24:40 +00:00

214 lines
5.8 KiB
Go

package service
import (
"context"
"errors"
"go.uber.org/zap"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/events/bus"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
)
var (
ErrTaskPlanNotFound = errors.New("task plan not found")
ErrTaskIDRequired = errors.New("task_id is required")
ErrContentRequired = errors.New("content is required")
)
// createdByAgent is the default creator for agent-created plans.
const createdByAgent = "agent"
// PlanService provides task plan business logic.
type PlanService struct {
repo repository.PlanRepository
eventBus bus.EventBus
logger *logger.Logger
}
// NewPlanService creates a new task plan service.
func NewPlanService(repo repository.PlanRepository, eventBus bus.EventBus, log *logger.Logger) *PlanService {
return &PlanService{
repo: repo,
eventBus: eventBus,
logger: log.WithFields(zap.String("component", "plan-service")),
}
}
// CreatePlanRequest contains parameters for creating a task plan.
type CreatePlanRequest struct {
TaskID string
Title string
Content string
CreatedBy string // "agent" or "user"
}
// CreatePlan creates a new task plan, or updates the existing one if a plan
// already exists for the given task (upsert semantics).
func (s *PlanService) CreatePlan(ctx context.Context, req CreatePlanRequest) (*models.TaskPlan, error) {
if req.TaskID == "" {
return nil, ErrTaskIDRequired
}
title := req.Title
if title == "" {
title = "Plan"
}
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = createdByAgent
}
// If a plan already exists for this task, update it instead of inserting.
existing, err := s.repo.GetTaskPlan(ctx, req.TaskID)
if err != nil {
s.logger.Error("failed to check existing task plan", zap.String("task_id", req.TaskID), zap.Error(err))
return nil, err
}
if existing != nil {
return s.UpdatePlan(ctx, UpdatePlanRequest{
TaskID: req.TaskID,
Title: title,
Content: req.Content,
CreatedBy: createdBy,
})
}
plan := &models.TaskPlan{
TaskID: req.TaskID,
Title: title,
Content: req.Content,
CreatedBy: createdBy,
}
if err := s.repo.CreateTaskPlan(ctx, plan); err != nil {
s.logger.Error("failed to create task plan", zap.String("task_id", req.TaskID), zap.Error(err))
return nil, err
}
s.logger.Info("created task plan", zap.String("task_id", req.TaskID), zap.String("plan_id", plan.ID))
s.publishEvent(ctx, events.TaskPlanCreated, plan)
return plan, nil
}
// GetPlan retrieves a task plan by task ID.
// Returns nil, nil if no plan exists.
func (s *PlanService) GetPlan(ctx context.Context, taskID string) (*models.TaskPlan, error) {
if taskID == "" {
return nil, ErrTaskIDRequired
}
plan, err := s.repo.GetTaskPlan(ctx, taskID)
if err != nil {
s.logger.Error("failed to get task plan", zap.String("task_id", taskID), zap.Error(err))
return nil, err
}
return plan, nil
}
// UpdatePlanRequest contains parameters for updating a task plan.
type UpdatePlanRequest struct {
TaskID string
Title string // Optional: if empty, preserves existing title
Content string
CreatedBy string // Optional: if empty, preserves existing or defaults to "user"
}
// UpdatePlan updates an existing task plan.
func (s *PlanService) UpdatePlan(ctx context.Context, req UpdatePlanRequest) (*models.TaskPlan, error) {
if req.TaskID == "" {
return nil, ErrTaskIDRequired
}
existing, err := s.repo.GetTaskPlan(ctx, req.TaskID)
if err != nil {
s.logger.Error("failed to get existing task plan", zap.String("task_id", req.TaskID), zap.Error(err))
return nil, err
}
if existing == nil {
return nil, ErrTaskPlanNotFound
}
// Preserve existing values if not provided
title := req.Title
if title == "" {
title = existing.Title
}
createdBy := req.CreatedBy
if createdBy == "" {
createdBy = existing.CreatedBy
}
plan := &models.TaskPlan{
ID: existing.ID,
TaskID: req.TaskID,
Title: title,
Content: req.Content,
CreatedBy: createdBy,
CreatedAt: existing.CreatedAt,
}
if err := s.repo.UpdateTaskPlan(ctx, plan); err != nil {
s.logger.Error("failed to update task plan", zap.String("task_id", req.TaskID), zap.Error(err))
return nil, err
}
s.logger.Info("updated task plan", zap.String("task_id", req.TaskID))
s.publishEvent(ctx, events.TaskPlanUpdated, plan)
return plan, nil
}
// DeletePlan deletes a task plan by task ID.
func (s *PlanService) DeletePlan(ctx context.Context, taskID string) error {
if taskID == "" {
return ErrTaskIDRequired
}
// Get plan before deleting for event payload
existing, err := s.repo.GetTaskPlan(ctx, taskID)
if err != nil {
s.logger.Error("failed to get task plan for delete", zap.String("task_id", taskID), zap.Error(err))
return err
}
if existing == nil {
return ErrTaskPlanNotFound
}
if err := s.repo.DeleteTaskPlan(ctx, taskID); err != nil {
s.logger.Error("failed to delete task plan", zap.String("task_id", taskID), zap.Error(err))
return err
}
s.logger.Info("deleted task plan", zap.String("task_id", taskID))
s.publishEvent(ctx, events.TaskPlanDeleted, existing)
return nil
}
// publishEvent publishes a task plan event to the event bus.
func (s *PlanService) publishEvent(ctx context.Context, eventType string, plan *models.TaskPlan) {
if s.eventBus == nil {
return
}
payload := map[string]interface{}{
"id": plan.ID,
"task_id": plan.TaskID,
"title": plan.Title,
"content": plan.Content,
"created_by": plan.CreatedBy,
"created_at": plan.CreatedAt,
"updated_at": plan.UpdatedAt,
}
if err := s.eventBus.Publish(ctx, eventType, bus.NewEvent(eventType, "plan-service", payload)); err != nil {
s.logger.Error("failed to publish task plan event", zap.String("event_type", eventType), zap.Error(err))
}
}