Implement more workflow management endpoints.

apognu · apognu · commit 88fc4eff8375 · 2025-06-23T10:28:38.000+02:00
diff --git a/api/handle_workflows.go b/api/handle_workflows.go
@@ -31,19 +31,19 @@ func handleListWorkflowsForScenario(uc usecases.Usecases) func(c *gin.Context) {
 func handleCreateWorkflowRule(uc usecases.Usecases) func(c *gin.Context) {
 	return func(c *gin.Context) {
 		ctx := c.Request.Context()
-		scenarioId := c.Param("scenarioId")
 
-		var payload dto.PostWorkflowRuleDto
+		var payload dto.CreateWorkflowRuleDto
 
 		if err := c.ShouldBindJSON(&payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
 			return
 		}
 
 		uc := usecasesWithCreds(ctx, uc)
 		scenarioUsecase := uc.NewScenarioUsecase()
 
 		params := models.WorkflowRule{
-			ScenarioId: scenarioId,
+			ScenarioId: payload.ScenarioId,
 			Name:       payload.Name,
 		}
 
@@ -59,22 +59,21 @@ func handleCreateWorkflowRule(uc usecases.Usecases) func(c *gin.Context) {
 func handleUpdateWorkflowRule(uc usecases.Usecases) func(c *gin.Context) {
 	return func(c *gin.Context) {
 		ctx := c.Request.Context()
-		scenarioId := c.Param("scenarioId")
 		ruleId := c.Param("ruleId")
 
-		var payload dto.PostWorkflowRuleDto
+		var payload dto.UpdateWorkflowRuleDto
 
 		if err := c.ShouldBindJSON(&payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
 			return
 		}
 
 		uc := usecasesWithCreds(ctx, uc)
 		scenarioUsecase := uc.NewScenarioUsecase()
 
 		params := models.WorkflowRule{
-			Id:         ruleId,
-			ScenarioId: scenarioId,
-			Name:       payload.Name,
+			Id:   ruleId,
+			Name: payload.Name,
 		}
 
 		rule, err := scenarioUsecase.UpdateWorkflowRule(ctx, params)
@@ -86,6 +85,144 @@ func handleUpdateWorkflowRule(uc usecases.Usecases) func(c *gin.Context) {
 	}
 }
 
+func handleCreateWorkflowCondition(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+		ruleId := c.Param("ruleId")
+
+		var payload dto.PostWorkflowConditionDto
+
+		if err := c.ShouldBindJSON(&payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+		if err := dto.ValidateWorkflowCondition(payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+
+		uc := usecasesWithCreds(ctx, uc)
+		scenarioUsecase := uc.NewScenarioUsecase()
+
+		params := models.WorkflowCondition{
+			RuleId:   ruleId,
+			Function: payload.Function,
+			Params:   payload.Params,
+		}
+
+		condition, err := scenarioUsecase.CreateWorkflowCondition(ctx, params)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		c.JSON(http.StatusCreated, dto.AdaptWorkflowCondition(condition))
+	}
+}
+
+func handleUpdateWorkflowCondition(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+		ruleId := c.Param("ruleId")
+		conditionId := c.Param("conditionId")
+
+		var payload dto.PostWorkflowConditionDto
+
+		if err := c.ShouldBindJSON(&payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+		if err := dto.ValidateWorkflowCondition(payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+
+		uc := usecasesWithCreds(ctx, uc)
+		scenarioUsecase := uc.NewScenarioUsecase()
+
+		params := models.WorkflowCondition{
+			Id:       conditionId,
+			RuleId:   ruleId,
+			Function: payload.Function,
+			Params:   payload.Params,
+		}
+
+		condition, err := scenarioUsecase.UpdateWorkflowCondition(ctx, params)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		c.JSON(http.StatusCreated, dto.AdaptWorkflowCondition(condition))
+	}
+}
+
+func handleCreateWorkflowAction(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+		ruleId := c.Param("ruleId")
+
+		var payload dto.PostWorkflowActionDto
+
+		if err := c.ShouldBindJSON(&payload); presentError(ctx, c, err) {
+			return
+		}
+		if err := dto.ValidateWorkflowAction(payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+
+		uc := usecasesWithCreds(ctx, uc)
+		scenarioUsecase := uc.NewScenarioUsecase()
+
+		params := models.WorkflowAction{
+			RuleId: ruleId,
+			Action: payload.Action,
+			Params: payload.Params,
+		}
+
+		action, err := scenarioUsecase.CreateWorkflowAction(ctx, params)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		c.JSON(http.StatusCreated, dto.AdaptWorkflowAction(action))
+	}
+}
+
+func handleUpdateWorkflowAction(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+		ruleId := c.Param("ruleId")
+		actionId := c.Param("actionId")
+
+		var payload dto.PostWorkflowActionDto
+
+		if err := c.ShouldBindJSON(&payload); presentError(ctx, c, err) {
+			return
+		}
+		if err := dto.ValidateWorkflowAction(payload); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+
+		uc := usecasesWithCreds(ctx, uc)
+		scenarioUsecase := uc.NewScenarioUsecase()
+
+		params := models.WorkflowAction{
+			Id:     actionId,
+			RuleId: ruleId,
+			Action: payload.Action,
+			Params: payload.Params,
+		}
+
+		action, err := scenarioUsecase.UpdateWorkflowAction(ctx, params)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		c.JSON(http.StatusCreated, dto.AdaptWorkflowAction(action))
+	}
+}
+
 func handleReorderWorkflowRules(uc usecases.Usecases) func(c *gin.Context) {
 	return func(c *gin.Context) {
 		ctx := c.Request.Context()
diff --git a/api/routes.go b/api/routes.go
@@ -290,6 +290,10 @@ func addRoutes(r *gin.Engine, conf Configuration, uc usecases.Usecases, auth uti
 
 	router.GET("/workflows/:scenarioId", tom, handleListWorkflowsForScenario(uc))
 	router.POST("/workflows/:scenarioId/reorder", tom, handleReorderWorkflowRules(uc))
-	router.POST("/workflows/:scenarioId/rule", tom, handleCreateWorkflowRule(uc))
-	router.PUT("/workflows/:scenarioId/rule/:ruleId", tom, handleUpdateWorkflowRule(uc))
+	router.POST("/workflows/rule", tom, handleCreateWorkflowRule(uc))
+	router.PUT("/workflows/rule/:ruleId", tom, handleUpdateWorkflowRule(uc))
+	router.POST("/workflows/rule/:ruleId/condition", tom, handleCreateWorkflowCondition(uc))
+	router.PUT("/workflows/rule/:ruleId/condition/:conditionId", tom, handleUpdateWorkflowCondition(uc))
+	router.POST("/workflows/rule/:ruleId/action", tom, handleCreateWorkflowAction(uc))
+	router.PUT("/workflows/rule/:ruleId/action/:actionId", tom, handleUpdateWorkflowAction(uc))
 }
diff --git a/dto/workflows.go b/dto/workflows.go
@@ -5,27 +5,45 @@ import (
 
 	"github.com/checkmarble/marble-backend/models"
 	"github.com/checkmarble/marble-backend/pure_utils"
+	"github.com/cockroachdb/errors"
+	"github.com/gin-gonic/gin/binding"
+	"github.com/go-playground/validator/v10"
 )
 
 type WorkflowRuleDto struct {
 	Id   string `json:"id"`
 	Name string `json:"name"`
 }
 
-type PostWorkflowRuleDto struct {
+type CreateWorkflowRuleDto struct {
+	ScenarioId string `json:"scenario_id" binding:"required,uuid"`
+	Name       string `json:"name" binding:"required"`
+}
+
+type UpdateWorkflowRuleDto struct {
 	Name string `json:"name" binding:"required"`
 }
 
 type WorkflowConditionDto struct {
-	Id       string          `json:"id"`
-	Function string          `json:"function"`
-	Params   json.RawMessage `json:"params"`
+	Id       string                       `json:"id"`
+	Function models.WorkflowConditionType `json:"function"`
+	Params   json.RawMessage              `json:"params,omitempty"`
+}
+
+type PostWorkflowConditionDto struct {
+	Function models.WorkflowConditionType `json:"function" binding:"required"`
+	Params   json.RawMessage              `json:"params"`
 }
 
 type WorkflowActionDto struct {
 	Id     string          `json:"id"`
 	Action string          `json:"action"`
-	Params json.RawMessage `json:"params"`
+	Params json.RawMessage `json:"params,omitempty"`
+}
+
+type PostWorkflowActionDto struct {
+	Action models.WorkflowType `json:"action" binding:"required"`
+	Params json.RawMessage     `json:"params"`
 }
 
 type WorkflowDto struct {
@@ -65,3 +83,38 @@ func AdaptWorkflowAction(m models.WorkflowAction) WorkflowActionDto {
 		Params: m.Params,
 	}
 }
+
+func ValidateWorkflowCondition(cond PostWorkflowConditionDto) error {
+	switch cond.Function {
+	case models.WorkflowConditionAlways, models.WorkflowConditionNever:
+		if cond.Params != nil {
+			return errors.Wrapf(models.BadParameterError, "workflow condition %s does not take parameters", cond.Function)
+		}
+	case models.WorkflowConditionIfOutcomeIn:
+		if err := json.Unmarshal(cond.Params, new([]string)); err != nil {
+			return errors.Join(models.BadParameterError, json.Unmarshal(cond.Params, new([]string)))
+		}
+	default:
+		return errors.Wrapf(models.BadParameterError, "unknown workflow condition type: %s", cond.Function)
+	}
+
+	return nil
+}
+
+func ValidateWorkflowAction(cond PostWorkflowActionDto) error {
+	switch cond.Action {
+	case models.WorkflowCreateCase, models.WorkflowAddToCaseIfPossible:
+		var params models.WorkflowCaseParams
+
+		if err := json.Unmarshal(cond.Params, &params); err != nil {
+			return errors.Join(models.BadParameterError, json.Unmarshal(cond.Params, new(models.WorkflowCaseParams)))
+		}
+		if err := binding.Validator.Engine().(*validator.Validate).Struct(params); err != nil {
+			return errors.Join(models.BadParameterError, err)
+		}
+	default:
+		return errors.Wrapf(models.BadParameterError, "unknown workflow action type: %s", cond.Action)
+	}
+
+	return nil
+}
diff --git a/integration_test/scenario_flow_test.go b/integration_test/scenario_flow_test.go
@@ -414,16 +414,16 @@ func setupScenarioAndPublish(
 		assert.FailNow(t, "Could not create workflow rule", err)
 	}
 
-	_, err = scenarioUsecase.CreateWorkflowCondition(ctx, organizationId, models.WorkflowCondition{
+	_, err = scenarioUsecase.CreateWorkflowCondition(ctx, models.WorkflowCondition{
 		RuleId:   rule.Id,
-		Function: "if_outcome_in",
+		Function: models.WorkflowConditionIfOutcomeIn,
 		Params:   []byte(`["decline", "review"]`),
 	})
 	if err != nil {
 		assert.FailNow(t, "Could not create workflow condition", err)
 	}
 
-	_, err = scenarioUsecase.CreateWorkflowAction(ctx, organizationId, models.WorkflowAction{
+	_, err = scenarioUsecase.CreateWorkflowAction(ctx, models.WorkflowAction{
 		RuleId: rule.Id,
 		Action: models.WorkflowAddToCaseIfPossible,
 		Params: fmt.Appendf(nil, `{"inbox_id": "%s"}`, inboxId),
diff --git a/models/workflows.go b/models/workflows.go
@@ -26,10 +26,40 @@ type WorkflowRule struct {
 	UpdatedAt *time.Time
 }
 
+type WorkflowConditionType string
+
+const (
+	WorkflowConditionUnknown     WorkflowConditionType = "unknown"
+	WorkflowConditionAlways                            = "always"
+	WorkflowConditionNever                             = "never"
+	WorkflowConditionIfOutcomeIn                       = "if_outcome_in"
+)
+
+var (
+	ValidWorkflowConditions = []WorkflowConditionType{
+		WorkflowConditionAlways,
+		WorkflowConditionNever,
+		WorkflowConditionIfOutcomeIn,
+	}
+)
+
+func WorkflowConditionFromString(s string) WorkflowConditionType {
+	switch s {
+	case WorkflowConditionAlways:
+		return WorkflowConditionAlways
+	case WorkflowConditionNever:
+		return WorkflowConditionNever
+	case WorkflowConditionIfOutcomeIn:
+		return WorkflowConditionIfOutcomeIn
+	default:
+		return WorkflowConditionUnknown
+	}
+}
+
 type WorkflowCondition struct {
 	Id       string
 	RuleId   string
-	Function string
+	Function WorkflowConditionType
 	Params   json.RawMessage
 
 	CreatedAt time.Time
@@ -67,8 +97,8 @@ type WorkflowActionSpec[T any] struct {
 }
 
 type WorkflowCaseParams struct {
-	InboxId       *uuid.UUID `json:"inbox_id"`
-	TitleTemplate *ast.Node  `json:"title_template"`
+	InboxId       uuid.UUID `json:"inbox_id" binding:"required,uuid"`
+	TitleTemplate *ast.Node `json:"title_template"`
 }
 
 type WorkflowExecution struct {
diff --git a/repositories/dbmodels/db_scenario_workflows.go b/repositories/dbmodels/db_scenario_workflows.go
@@ -69,7 +69,7 @@ func AdaptWorkflowCondition(db DbWorkflowCondition) (models.WorkflowCondition, e
 	return models.WorkflowCondition{
 		Id:        db.Id,
 		RuleId:    db.RuleId,
-		Function:  db.Function,
+		Function:  models.WorkflowConditionFromString(db.Function),
 		Params:    db.Params,
 		CreatedAt: db.CreatedAt,
 		UpdatedAt: db.UpdatedAt,
diff --git a/repositories/workflows_repositories.go b/repositories/workflows_repositories.go
diff --git a/usecases/decision_workflows/actions_case.go b/usecases/decision_workflows/actions_case.go
diff --git a/usecases/workflows_usecase.go b/usecases/workflows_usecase.go
