pelican/internal/board/board.go

package board

import (
	"fmt"
	"sort"

	"forge.dananglin.me.uk/code/dananglin/pelican/internal/card"
	"forge.dananglin.me.uk/code/dananglin/pelican/internal/database"
	"forge.dananglin.me.uk/code/dananglin/pelican/internal/status"
	bolt "go.etcd.io/bbolt"
)

// LoadBoard reads the board from the database. If no board exists then a new one will be created.
func LoadBoard(path string) (*bolt.DB, error) {
	db, err := database.OpenDatabase(path)
	if err != nil {
		return nil, fmt.Errorf("unable to open the database, %w", err)
	}

	statusList, err := ReadStatusList(db)
	if err != nil {
		return nil, err
	}

	if len(statusList) == 0 {
		newStatusList := status.NewDefaultStatusList()
		if err := database.WriteStatusList(db, newStatusList); err != nil {
			return nil, fmt.Errorf("unable to save the default status list to the database, %w", err)
		}
	}

	return db, nil
}

// ReadStatusList returns an ordered list of statuses from the database.
func ReadStatusList(db *bolt.DB) ([]status.Status, error) {
	statuses, err := database.ReadStatusList(db)
	if err != nil {
		return statuses, fmt.Errorf("unable to read the status list, %w", err)
	}

	sort.Sort(status.ByStatusOrder(statuses))

	return statuses, nil
}

// TODO: Finish implementation.
func ReadStatus(db *bolt.DB) (status.Status, error) {
	return status.Status{}, nil
}

// TODO: Finish implementation.
func CreateStatus(db *bolt.DB) error {
	return nil
}

// TODO: Finish implementation.
func UpdateStatus(db *bolt.DB) error {
	return nil
}

// TODO: Finish implementation.
func DeleteStatus(db *bolt.DB) error {
	return nil
}

// CreateCard creates a card in the database.
func CreateCard(db *bolt.DB, title, content string) error {
	statusList, err := database.ReadStatusList(db)
	if err != nil {
		return fmt.Errorf("unable to read the status list, %w", err)
	}

	if len(statusList) == 0 {
		return statusListEmptyError{}
	}

	card := card.Card{
		ID:      -1,
		Title:   title,
		Content: content,
	}

	cardID, err := database.WriteCard(db, card)
	if err != nil {
		return fmt.Errorf("unable to write card to the database, %w", err)
	}

	cardIDs := statusList[0].CardIds

	cardIDs = append(cardIDs, cardID)

	statusList[0].CardIds = cardIDs

	// TODO: change the below to save a single status
	if err := database.WriteStatusList(db, statusList); err != nil {
		return fmt.Errorf("unable to write status list to the database, %w", err)
	}

	return nil
}

// ReadCard returns a Card value from the database.
func ReadCard(db *bolt.DB, id int) (card.Card, error) {
	c, err := database.ReadCard(db, id)
	if err != nil {
		return card.Card{}, fmt.Errorf("unable to read card [%d] from the database, %w", id, err)
	}

	return c, nil
}

// UpdateCard modifies an existing card and saves the modification to the database.
func UpdateCard(db *bolt.DB, id int, title, content string) error {
	c, err := ReadCard(db, id)
	if err != nil {
		return err
	}

	c.Title = title
	c.Content = content

	if _, err := database.WriteCard(db, c); err != nil {
		return fmt.Errorf("unable to write card to the database, %w", err)
	}

	return nil
}

// MoveCard moves a card between statuses.
// TODO: finish implementation.
func MoveCard(db *bolt.DB, fromStatusID, toStatusID int) error {
	return nil
}

// DeleteCard deletes a card from the database.
// TODO: finish implementation.
func DeleteCard(db *bolt.DB, id int) error {
	return nil
}