Workitems limited by workspace

Author: stefan-ernst

internal/restapi/v1/handlers/items.go

@@ -237,6 +237,19 @@ func (h *ItemHandler) Create(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Check item type is allowed in workspace config set
+	if req.ItemTypeID != nil && *req.ItemTypeID != 0 {
+		allowed, checkErr := services.IsItemTypeAllowedInWorkspace(h.db, req.WorkspaceID, *req.ItemTypeID)
+		if checkErr != nil {
+			restapi.RespondError(w, r, restapi.ErrInternalError)
+			return
+		}
+		if !allowed {
+			restapi.RespondError(w, r, restapi.NewAPIError(http.StatusBadRequest, restapi.ErrCodeValidationFailed, "Item type is not allowed in this workspace"))
+			return
+		}
+	}
+
 	// Sanitize user input to prevent XSS
 	req.Title = utils.StripHTMLTags(req.Title)
 	req.Description = utils.SanitizeCommentContent(req.Description)

internal/restapi/v1/handlers/workspaces.go

@@ -389,3 +389,48 @@ func (h *WorkspaceHandler) GetStatuses(w http.ResponseWriter, r *http.Request) {
 
 	restapi.RespondOK(w, result)
 }
+
+// GetItemTypes handles GET /rest/api/v1/workspaces/{id}/item-types
+func (h *WorkspaceHandler) GetItemTypes(w http.ResponseWriter, r *http.Request) {
+	user, ok := requireAuth(w, r)
+	if !ok {
+		return
+	}
+
+	wsID, ok := parsePathID(w, r, "id", "workspace ID")
+	if !ok {
+		return
+	}
+
+	canView, _ := h.perms.CanViewWorkspace(user.ID, wsID)
+	if !canView {
+		restapi.RespondError(w, r, restapi.ErrWorkspaceNotFound)
+		return
+	}
+
+	types, err := h.workspaceService.GetItemTypes(wsID)
+	if err != nil {
+		restapi.RespondError(w, r, restapi.ErrInternalError)
+		return
+	}
+
+	var result []ItemTypeResponse
+	for _, t := range types {
+		result = append(result, ItemTypeResponse{
+			ID:             t.ID,
+			Name:           t.Name,
+			Description:    t.Description,
+			Icon:           t.Icon,
+			Color:          t.Color,
+			HierarchyLevel: t.HierarchyLevel,
+			SortOrder:      t.SortOrder,
+			IsDefault:      t.IsDefault,
+		})
+	}
+
+	if result == nil {
+		result = []ItemTypeResponse{}
+	}
+
+	restapi.RespondOK(w, result)
+}

internal/restapi/v1/router.go

@@ -72,6 +72,7 @@ func RegisterRoutes(
 	v1.HandleWithMiddleware("DELETE /workspaces/{id}", workspaceHandler.Delete, router.RequireNumericID)
 	v1.HandleWithMiddleware("GET /workspaces/{id}/items", workspaceHandler.GetItems, router.RequireNumericID)
 	v1.HandleWithMiddleware("GET /workspaces/{id}/statuses", workspaceHandler.GetStatuses, router.RequireNumericID)
+	v1.HandleWithMiddleware("GET /workspaces/{id}/item-types", workspaceHandler.GetItemTypes, router.RequireNumericID)
 
 	// ============================================
 	// Statuses & Status Categories

internal/services/item_validation.go

@@ -27,6 +27,34 @@ type ItemValidationResult struct {
 	Error string
 }
 
+// IsItemTypeAllowedInWorkspace checks whether the given item type is allowed
+// in the workspace's configuration set. Returns true when:
+//   - the workspace has no configuration set (all types allowed), or
+//   - the item type appears in configuration_set_item_types for that config set.
+func IsItemTypeAllowedInWorkspace(db database.Database, workspaceID, itemTypeID int) (bool, error) {
+	var configSetID *int
+	err := db.QueryRow(
+		"SELECT configuration_set_id FROM workspace_configuration_sets WHERE workspace_id = ?",
+		workspaceID,
+	).Scan(&configSetID)
+	if err == sql.ErrNoRows || configSetID == nil {
+		return true, nil // no config set → all types allowed
+	}
+	if err != nil {
+		return false, fmt.Errorf("failed to query workspace config set: %w", err)
+	}
+
+	var exists bool
+	err = db.QueryRow(
+		"SELECT EXISTS(SELECT 1 FROM configuration_set_item_types WHERE configuration_set_id = ? AND item_type_id = ?)",
+		*configSetID, itemTypeID,
+	).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("failed to check item type in config set: %w", err)
+	}
+	return exists, nil
+}
+
 // ValidateItemCreation validates all parameters for creating an item
 // Returns a validation result indicating success or failure with error message
 func ValidateItemCreation(db database.Database, params ItemValidationParams) *ItemValidationResult {

internal/services/items.go

@@ -99,6 +99,17 @@ type ItemCreationParams struct {
 // CreateItem creates a new item with proper transaction handling and number generation
 // This centralizes the item creation logic used by normal creation, portal submissions, and copying
 func CreateItem(db database.Database, params ItemCreationParams) (int64, error) {
+	// Enforce config set item type restrictions before anything else
+	if params.ItemTypeID != nil && *params.ItemTypeID != 0 {
+		allowed, err := IsItemTypeAllowedInWorkspace(db, params.WorkspaceID, *params.ItemTypeID)
+		if err != nil {
+			return 0, fmt.Errorf("failed to check item type restriction: %w", err)
+		}
+		if !allowed {
+			return 0, fmt.Errorf("item type is not allowed in this workspace")
+		}
+	}
+
 	now := time.Now()
 
 	// Generate fractional index for manual ordering

internal/services/workspace_service.go

@@ -326,6 +326,53 @@ func (s *WorkspaceService) GetStatuses(workspaceID int) ([]models.Status, error)
 	return statuses, nil
 }
 
+// GetItemTypes retrieves item types available for a workspace via its configuration set.
+// If the workspace has a config set with item types defined, only those are returned.
+// If no config set exists, all item types are returned.
+func (s *WorkspaceService) GetItemTypes(workspaceID int) ([]ItemTypeResult, error) {
+	rows, err := s.db.Query(`
+		SELECT DISTINCT it.id, it.name, it.description, it.icon, it.color,
+		       it.hierarchy_level, it.sort_order, it.is_default
+		FROM item_types it
+		WHERE NOT EXISTS (
+			SELECT 1 FROM workspace_configuration_sets wcs
+			JOIN configuration_set_item_types csit ON wcs.configuration_set_id = csit.configuration_set_id
+			WHERE wcs.workspace_id = ?
+		)
+		OR EXISTS (
+			SELECT 1 FROM workspace_configuration_sets wcs
+			JOIN configuration_set_item_types csit ON wcs.configuration_set_id = csit.configuration_set_id
+			WHERE wcs.workspace_id = ? AND csit.item_type_id = it.id
+		)
+		ORDER BY it.hierarchy_level, it.sort_order, it.name
+	`, workspaceID, workspaceID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get workspace item types: %w", err)
+	}
+	defer rows.Close()
+
+	var types []ItemTypeResult
+	for rows.Next() {
+		var t ItemTypeResult
+		var description, icon, color sql.NullString
+		err := rows.Scan(&t.ID, &t.Name, &description, &icon, &color,
+			&t.HierarchyLevel, &t.SortOrder, &t.IsDefault)
+		if err != nil {
+			continue
+		}
+		t.Description = description.String
+		t.Icon = icon.String
+		t.Color = color.String
+		types = append(types, t)
+	}
+
+	if types == nil {
+		types = []ItemTypeResult{}
+	}
+
+	return types, nil
+}
+
 // GetRepository returns the underlying workspace repository for advanced operations.
 func (s *WorkspaceService) GetRepository() *repository.WorkspaceRepository {
 	return s.repo