Merge pull request #8 from owlistic-notes/block-task-improvements

Block task improvements

Author: DavideRutigliano

src/backend/models/block.go

@@ -13,28 +13,13 @@ import (
 type BlockType string
 
 const (
-	TextBlock      BlockType = "text"
-	TaskBlock      BlockType = "task"
+	TextBlock    BlockType = "text"
+	TaskBlock    BlockType = "task"
+	HeadingBlock BlockType = "heading"
 )
 
-// BlockContent stores the structured content of a block
 type BlockContent map[string]interface{}
 
-// InlineStyle represents a formatting span within block text
-type InlineStyle struct {
-	Type  string `json:"type"`
-	Start int    `json:"start"`
-	End   int    `json:"end"`
-	Href  string `json:"href,omitempty"` // For link styles
-}
-
-// StyleOptions defines the styling configuration for a block's content
-type StyleOptions struct {
-	RawMarkdown    string        `json:"raw_markdown,omitempty"`    // Original markdown text
-	InlineStyles   []InlineStyle `json:"styles,omitempty"`          // Extracted style information
-	PreserveFormat bool          `json:"preserve_format,omitempty"` // Whether to preserve formatting in storage
-}
-
 // Value implements the driver.Valuer interface for JSONB storage
 func (bc BlockContent) Value() (driver.Value, error) {
 	if bc == nil {
@@ -58,55 +43,92 @@ func (bc *BlockContent) Scan(value interface{}) error {
 	return json.Unmarshal(bytes, bc)
 }
 
+// BlockMetadata stores flexible metadata specific to each block type
+type BlockMetadata map[string]interface{}
+
+// Value implements the driver.Valuer interface for JSONB storage
+func (bm BlockMetadata) Value() (driver.Value, error) {
+	if bm == nil {
+		return nil, nil
+	}
+	return json.Marshal(bm)
+}
+
+// Scan implements the sql.Scanner interface for JSONB retrieval
+func (bm *BlockMetadata) Scan(value interface{}) error {
+	if value == nil {
+		*bm = make(BlockMetadata)
+		return nil
+	}
+
+	bytes, ok := value.([]byte)
+	if !ok {
+		return errors.New("type assertion to []byte failed")
+	}
+
+	return json.Unmarshal(bytes, bm)
+}
+
 // Block represents a content block within a note
 type Block struct {
 	ID        uuid.UUID      `gorm:"type:uuid;primaryKey;default:gen_random_uuid()" json:"id"`
 	UserID    uuid.UUID      `gorm:"type:uuid;not null;constraint:OnDelete:CASCADE;" json:"user_id"`
 	NoteID    uuid.UUID      `gorm:"type:uuid;not null;constraint:OnDelete:CASCADE;" json:"note_id"`
 	Type      BlockType      `gorm:"type:varchar(20);not null" json:"type"`
-	Content   BlockContent   `gorm:"type:jsonb;not null;default:'{}'::jsonb" json:"content"`
-	Metadata  BlockContent   `gorm:"type:jsonb;default:'{}'::jsonb" json:"metadata,omitempty"`
-	Tasks     []Task         `gorm:"foreignKey:BlockID" json:"tasks,omitempty"`
-	Order     float64        `gorm:"not null" json:"order"` // Changed from int to float64
+	Content   BlockContent   `gorm:"type:jsonb;default:'{}'::jsonb" json:"content"`
+	Metadata  BlockMetadata  `gorm:"type:jsonb;default:'{}'::jsonb" json:"metadata"`
+	Order     float64        `gorm:"not null" json:"order"`
 	CreatedAt time.Time      `gorm:"not null;default:now()" json:"created_at"`
 	UpdatedAt time.Time      `gorm:"not null;default:now()" json:"updated_at"`
 	DeletedAt gorm.DeletedAt `gorm:"index" json:"deleted_at,omitempty"`
 }
 
-// GetInlineStyles returns the block's inline style information
-func (b *Block) GetInlineStyles() []InlineStyle {
-	if b.Content == nil {
-		return nil
+// GetHeadingLevel returns the heading level (for heading blocks)
+func (b *Block) GetHeadingLevel() int {
+	if b.Type != HeadingBlock {
+		return 0
+	}
+
+	if level, ok := b.Metadata["level"].(float64); ok {
+		return int(level)
 	}
+	return 1 // Default heading level
+}
 
-	// Try getting styles directly from the content map
-	if spans, ok := b.Content["spans"].([]interface{}); ok {
-		styles := make([]InlineStyle, 0, len(spans))
+// GetSpans returns formatting spans from metadata
+func (b *Block) GetSpans() []map[string]interface{} {
+	if spans, ok := b.Metadata["spans"].([]interface{}); ok {
+		result := make([]map[string]interface{}, 0, len(spans))
 		for _, span := range spans {
 			if spanMap, ok := span.(map[string]interface{}); ok {
-				style := InlineStyle{}
-
-				if t, ok := spanMap["type"].(string); ok {
-					style.Type = t
-				}
-
-				if start, ok := spanMap["start"].(float64); ok {
-					style.Start = int(start)
-				}
+				result = append(result, spanMap)
+			}
+		}
+		return result
+	}
+	return nil
+}
 
-				if end, ok := spanMap["end"].(float64); ok {
-					style.End = int(end)
-				}
+// IsTaskCompleted returns whether a task is completed (for task blocks)
+func (b *Block) IsTaskCompleted() bool {
+	if b.Type != TaskBlock {
+		return false
+	}
 
-				if href, ok := spanMap["href"].(string); ok {
-					style.Href = href
-				}
+	if completed, ok := b.Metadata["is_completed"].(bool); ok {
+		return completed
+	}
+	return false
+}
 
-				styles = append(styles, style)
-			}
-		}
-		return styles
+// GetTaskID returns the associated task ID (for task blocks)
+func (b *Block) GetTaskID() string {
+	if b.Type != TaskBlock {
+		return ""
 	}
 
-	return nil
+	if taskID, ok := b.Metadata["task_id"].(string); ok {
+		return taskID
+	}
+	return ""
 }

src/backend/models/block_test.go

@@ -14,9 +14,8 @@ func TestBlockJSON(t *testing.T) {
 		NoteID:   uuid.New(),
 		Type:     TextBlock,
 		Content:  BlockContent{"text": "Test Content"},
-		Metadata: BlockContent{"format": "markdown"},
+		Metadata: BlockMetadata{"format": "markdown"},
 		Order:    1,
-		Tasks:    []Task{},
 	}
 
 	data, err := json.Marshal(block)
@@ -36,7 +35,7 @@ func TestBlockWithTasks(t *testing.T) {
 	task := Task{
 		ID:          uuid.New(),
 		UserID:      uuid.New(),
-		BlockID:     uuid.New(),
+		NoteID:      uuid.New(),
 		Title:       "Test Task",
 		Description: "Test Description",
 	}
@@ -46,7 +45,7 @@ func TestBlockWithTasks(t *testing.T) {
 		NoteID:  uuid.New(),
 		Type:    TaskBlock,
 		Content: BlockContent{"text": "Task Block"},
-		Tasks:   []Task{task},
+		Metadata: BlockMetadata{"task_id": task.ID},
 		Order:   1,
 	}
 
@@ -56,8 +55,7 @@ func TestBlockWithTasks(t *testing.T) {
 	var result Block
 	err = json.Unmarshal(data, &result)
 	assert.NoError(t, err)
-	assert.Equal(t, 1, len(result.Tasks))
-	assert.Equal(t, task.Title, result.Tasks[0].Title)
+	assert.Equal(t, task.ID, result.GetTaskID())
 }
 
 func TestBlockContentSerialization(t *testing.T) {

src/backend/models/task.go

@@ -39,7 +39,7 @@ func (tm *TaskMetadata) Scan(value interface{}) error {
 type Task struct {
 	ID          uuid.UUID      `gorm:"type:uuid;primaryKey;default:gen_random_uuid()" json:"id"`
 	UserID      uuid.UUID      `gorm:"type:uuid;not null;constraint:OnDelete:CASCADE;" json:"user_id"`
-	BlockID     uuid.UUID      `gorm:"type:uuid;constraint:OnDelete:CASCADE;" json:"block_id"`
+	NoteID      uuid.UUID      `gorm:"type:uuid;not null;constraint:OnDelete:CASCADE;" json:"note_id"` // Direct note relationship
 	Title       string         `gorm:"not null" json:"title"`
 	Description string         `json:"description"`
 	IsCompleted bool           `gorm:"default:false" json:"is_completed"`

src/backend/routes/blocks_test.go

@@ -195,39 +195,6 @@ func (m *MockBlockService) ListBlocksByNote(db *database.Database, noteID string
 	return []models.Block{}, nil
 }
 
-// GetBlockWithStyles retrieves a block with its associated style information
-func (m *MockBlockService) GetBlockWithStyles(db *database.Database, id string, params map[string]interface{}) (models.Block, map[string]interface{}, error) {
-	// Check permissions using the params (simplified for tests)
-	_, hasUserID := params["user_id"]
-	if !hasUserID {
-		return models.Block{}, nil, errors.New("user_id must be provided in parameters")
-	}
-
-	if id == "123e4567-e89b-12d3-a456-426614174000" {
-		block := models.Block{
-			ID:      uuid.Must(uuid.Parse(id)),
-			NoteID:  uuid.Must(uuid.Parse("90a12345-f12a-98c4-a456-513432930000")),
-			Type:    models.TextBlock,
-			Content: models.BlockContent{"text": "Test Content"},
-			Order:   1,
-		}
-
-		styleInfo := map[string]interface{}{
-			"spans": []map[string]interface{}{
-				{
-					"start": 0,
-					"end":   4,
-					"type":  "bold",
-				},
-			},
-		}
-
-		return block, styleInfo, nil
-	}
-
-	return models.Block{}, nil, services.ErrBlockNotFound
-}
-
 func TestCreateBlock(t *testing.T) {
 	router := gin.Default()
 	db := &database.Database{}

src/backend/routes/tasks.go

@@ -171,8 +171,8 @@ func GetTasks(c *gin.Context, db *database.Database, taskService services.TaskSe
 		params["block_id"] = blockID
 	}
 
-	if completed := c.Query("completed"); completed != "" {
-		params["completed"] = completed
+	if completed := c.Query("is_completed"); completed != "" {
+		params["is_completed"] = completed
 	}
 
 	if title := c.Query("title"); title != "" {

src/backend/routes/tasks_test.go

@@ -20,7 +20,7 @@ type MockTaskService struct{}
 // Add GetTasks method for query parameter support
 func (m *MockTaskService) GetTasks(db *database.Database, params map[string]interface{}) ([]models.Task, error) {
 	userID, hasUserID := params["user_id"].(string)
-	completed, hasCompleted := params["completed"].(string)
+	completed, hasCompleted := params["is_completed"].(string)
 
 	tasks := []models.Task{
 		{
@@ -72,17 +72,17 @@ func (m *MockTaskService) CreateTask(db *database.Database, taskData map[string]
 		userID = uuid.Must(uuid.Parse(userIDStr))
 	}
 
-	blockID := uuid.New()
+	noteID := uuid.New()
 	noteIDStr, noteIDExists := taskData["note_id"].(string)
 	if noteIDExists && noteIDStr != "" {
 		// Simulate finding or creating a block for the note
-		blockID = uuid.New()
+		noteID = uuid.New()
 	}
 
 	return models.Task{
 		ID:      uuid.New(),
 		UserID:  userID,
-		BlockID: blockID,
+		NoteID:  noteID,
 		Title:   title,
 	}, nil
 }