Add handlers

api/cmd/main.go

@@ -5,16 +5,16 @@ import (
 	"syscall"
 
 	"github.com/echo-webkom/ludo/api/config"
+	"github.com/echo-webkom/ludo/api/database"
 	"github.com/echo-webkom/ludo/api/server"
-	"github.com/echo-webkom/ludo/api/service"
 	"github.com/jesperkha/notifier"
 )
 
 func main() {
 	config := config.Load()
 	notif := notifier.New()
-	service := service.New(config)
-	server := server.New(config, service)
+	db := database.NewTursoDB(config)
+	server := server.New(config, db)
 
 	go server.ListenAndServe(notif)
 

api/database/database.go

@@ -2,21 +2,27 @@ package database
 
 type Database interface {
 	GetUserById(id uint) (User, error)
+	UpdateUser(id uint, user User) error
+	CreateUser(user User) (uint, error)
 	DeleteUserById(id uint) error
 	GetAllUsers() ([]User, error)
-
+	
 	GetItemById(id uint) (Item, error)
-	CreateItem(item Item) error
+	CreateItem(item Item) (uint, error)
 	GetAllItems() ([]Item, error)
 	DeleteItemByID(id uint) error
-	GetAllItemsFromLits(list List) ([]Item, error)
-	MoveItemToList(id uint, list List) error
-	ChangeItemTitle(id uint, title string) error
-	ChangeItemDescription(id uint, description string) error
-
-	CreateNewRepo(name, url string) error
-	DeleteRepoById(id uint) error
+	GetAllItemsFromList(boardId, list uint) ([]Item, error)
+	MoveItemToList(id uint, list uint) error
+	UpdateItem(id uint, item Item) error
+
+	GetAllBoards() ([]Board, error)
+	CreateBoard(board Board) (uint, error)
+	GetBoardById(id uint) (Board, error)
+	UpdateBoard(id uint, board Board) error
+	DeleteBoardById(id uint) error
 
-	// Username must be identical to GitHub username.
-	CreateUser(username string) error
+	GetBoardUsers(boardId uint) ([]User, error)
+	GetBoardItems(boardId uint) ([]Item, error)
+	AddUserToBoard(boardId, userId uint) error
+	RemoveUserFromBoard(boardId, userId uint) error
 }

api/database/model.go

@@ -1,40 +1,35 @@
 package database
 
 import (
-	"gorm.io/gorm"
+	"time"
 )
 
-type List int
+type model struct {
+	ID        uint      `gorm:"primarykey" json:"id"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+}
 
-const (
-	BACKLOG = iota
-	TODO
-	DOING
-	REVIEW
-	DONE
-)
+type Board struct {
+	model
+	Items []Item `json:"items"`
+	Users []User `gorm:"many2many:board_users;" json:"users"`
+}
 
 type Item struct {
-	gorm.Model
-	RepoID          uint
-	Repo            Repo
-	Title           string
-	Description     string
-	CreatorID       uint
-	Creator         User
-	AssigneeID      uint
-	Assignee        User
-	ConnectedBranch string
-	List            List
+	model
+	RepoName        string `json:"repoName"`
+	RepoURL         string `json:"repoURL"`
+	Title           string `json:"title"`
+	Description     string `json:"description"`
+	ConnectedBranch string `json:"connectedBranch"`
+	List            uint   `json:"list"`
+	Creator         User   `gorm:"many2many:item_user;" json:"creator"`
+	Assignee        User   `gorm:"many2many:item_user;" json:"assignee"`
 }
 
 type User struct {
-	gorm.Model
-	Name string
-}
-
-type Repo struct {
-	gorm.Model
-	Name string
-	URL  string
+	model
+	DisplayName    string `json:"displayName"`
+	GithubUsername string `json:"githubUsername"`
 }

api/database/query.go

@@ -7,18 +7,25 @@ import (
 func (db *tursoDB) GetUserById(id uint) (User, error) {
 	var user User
 	if res := db.db.First(&user, id); res.Error != nil {
-		return User{}, errors.New("could not find usre with id")
+		return User{}, errors.New("could not find user with id")
 	}
 	return user, nil
 }
 
-func (db *tursoDB) CreateUser(name string) error {
-	if res := db.db.Create(User{Name: name}); res.Error != nil {
-		return errors.New("could not create a new user")
+func (db *tursoDB) UpdateUser(id uint, user User) error {
+	if res := db.db.Model(&User{}).Where("id = ?", id).Updates(user); res.Error != nil {
+		return errors.New("could not update user")
 	}
 	return nil
 }
 
+func (db *tursoDB) CreateUser(user User) (uint, error) {
+	if res := db.db.Create(&user); res.Error != nil {
+		return 0, errors.New("could not create a new user")
+	}
+	return user.ID, nil
+}
+
 func (db *tursoDB) DeleteUserById(id uint) error {
 	if res := db.db.Delete(&User{}, id); res.Error != nil {
 		return errors.New("could not delete user")
@@ -29,29 +36,29 @@ func (db *tursoDB) DeleteUserById(id uint) error {
 func (db *tursoDB) GetAllUsers() ([]User, error) {
 	var users []User
 	if res := db.db.Find(&users); res.Error != nil {
-		return nil, errors.New("courl not get all userts")
+		return nil, errors.New("could not get all users")
 	}
 	return users, nil
 }
 
 func (db *tursoDB) GetItemById(id uint) (Item, error) {
 	var item Item
-	if res := db.db.First(&item, id); res.Error != nil {
+	if res := db.db.Preload("Creator").Preload("Assignee").First(&item, id); res.Error != nil {
 		return Item{}, errors.New("could not get item")
 	}
 	return item, nil
 }
 
-func (db *tursoDB) CreateItem(item Item) error {
+func (db *tursoDB) CreateItem(item Item) (uint, error) {
 	if res := db.db.Create(&item); res.Error != nil {
-		return errors.New("could not create	item")
+		return 0, errors.New("could not create item")
 	}
-	return nil
+	return item.ID, nil
 }
 
 func (db *tursoDB) GetAllItems() ([]Item, error) {
 	var items []Item
-	if res := db.db.Find(&items); res.Error != nil {
+	if res := db.db.Preload("Creator").Preload("Assignee").Find(&items); res.Error != nil {
 		return nil, errors.New("could not get all items")
 	}
 	return items, nil
@@ -64,46 +71,118 @@ func (db *tursoDB) DeleteItemByID(id uint) error {
 	return nil
 }
 
-func (db *tursoDB) GetAllItemsFromLits(list List) ([]Item, error) {
-	var items []Item
-	if res := db.db.Find(&items, "list = ?", list); res.Error != nil {
-		return nil, errors.New("could not find all items from list")
+func (db *tursoDB) GetAllItemsFromList(boardId, list uint) ([]Item, error) {
+	var board Board
+	if res := db.db.Preload("Items", "list = ?", list).First(&board, boardId); res.Error != nil {
+		return nil, errors.New("could not find board")
 	}
-	return items, nil
+
+	for i := range board.Items {
+		db.db.Preload("Creator").Preload("Assignee").First(&board.Items[i], board.Items[i].ID)
+	}
+
+	return board.Items, nil
 }
 
-func (db *tursoDB) MoveItemToList(id uint, list List) error {
+func (db *tursoDB) MoveItemToList(id uint, list uint) error {
 	if res := db.db.Model(&Item{}).Where("id = ?", id).Update("list", list); res.Error != nil {
 		return errors.New("could not move item")
 	}
 	return nil
 }
 
-func (db *tursoDB) ChangeItemTitle(id uint, title string) error {
-	if res := db.db.Model(&Item{}).Where("id = ?", id).Update("title", title); res.Error != nil {
-		return errors.New("could not change item title")
+func (db *tursoDB) UpdateItem(id uint, item Item) error {
+	if res := db.db.Model(&Item{}).Where("id = ?", id).Updates(item); res.Error != nil {
+		return errors.New("could not update item")
 	}
 	return nil
 }
 
-func (db *tursoDB) ChangeItemDescription(id uint, description string) error {
-	if res := db.db.Model(&Item{}).Where("id = ?", id).Update("description", description); res.Error != nil {
-		return errors.New("could not change item description")
+func (db *tursoDB) GetAllBoards() ([]Board, error) {
+	var boards []Board
+	if res := db.db.Preload("Items").Preload("Users").Find(&boards); res.Error != nil {
+		return nil, errors.New("could not find boards")
+	}
+	return boards, nil
+}
+
+func (db *tursoDB) CreateBoard(board Board) (uint, error) {
+	if res := db.db.Create(&board); res.Error != nil {
+		return 0, errors.New("could not create a new board")
+	}
+	return board.ID, nil
+}
+
+func (db *tursoDB) GetBoardById(id uint) (Board, error) {
+	var board Board
+	if res := db.db.Preload("Items").Preload("Users").First(&board, id); res.Error != nil {
+		return Board{}, errors.New("could not find board")
+	}
+	return board, nil
+}
+
+func (db *tursoDB) UpdateBoard(id uint, board Board) error {
+	if res := db.db.Model(&Board{}).Where("id = ?", id).Updates(board); res.Error != nil {
+		return errors.New("could not update board")
 	}
 	return nil
 }
 
-func (db *tursoDB) CreateNewRepo(name, url string) error {
-	repo := Repo{Name: name, URL: url}
-	if res := db.db.Create(&repo); res.Error != nil {
-		return errors.New("could not create new user")
+func (db *tursoDB) DeleteBoardById(id uint) error {
+	if res := db.db.Delete(&Board{}, id); res.Error != nil {
+		return errors.New("could not delete board")
 	}
 	return nil
 }
 
-func (db *tursoDB) DeleteRepoById(id uint) error {
-	if res := db.db.Delete(&Repo{}, id); res.Error != nil {
-		return errors.New("could not delet the repo")
+func (db *tursoDB) GetBoardUsers(boardId uint) ([]User, error) {
+	var board Board
+	if res := db.db.Preload("Users").First(&board, boardId); res.Error != nil {
+		return nil, errors.New("could not find board")
 	}
+	return board.Users, nil
+}
+
+func (db *tursoDB) GetBoardItems(boardId uint) ([]Item, error) {
+	var board Board
+	if res := db.db.Preload("Items").Preload("Items.Creator").Preload("Items.Assignee").First(&board, boardId); res.Error != nil {
+		return nil, errors.New("could not find board")
+	}
+	return board.Items, nil
+}
+
+func (db *tursoDB) AddUserToBoard(boardId, userId uint) error {
+	var board Board
+	if res := db.db.First(&board, boardId); res.Error != nil {
+		return errors.New("could not find board")
+	}
+
+	var user User
+	if res := db.db.First(&user, userId); res.Error != nil {
+		return errors.New("could not find user")
+	}
+
+	if res := db.db.Model(&board).Association("Users").Append(&user); res != nil {
+		return errors.New("could not add user to board")
+	}
+
 	return nil
 }
+
+func (db *tursoDB) RemoveUserFromBoard(boardId, userId uint) error {
+	var board Board
+	if res := db.db.First(&board, boardId); res.Error != nil {
+		return errors.New("could not find board")
+	}
+
+	var user User
+	if res := db.db.First(&user, userId); res.Error != nil {
+		return errors.New("could not find user")
+	}
+
+	if res := db.db.Model(&board).Association("Users").Delete(&user); res != nil {
+		return errors.New("could not remove user from board")
+	}
+
+	return nil
+}

api/database/turso.go

@@ -32,7 +32,7 @@ func NewTursoDB(config *config.Config) Database {
 		log.Fatal("could not load remote database", err)
 	}
 
-	if err := db.AutoMigrate(&Item{}, &User{}, &Repo{}); err != nil {
+	if err := db.AutoMigrate(&Item{}, &User{}, &Board{}); err != nil {
 		log.Fatalf("migration: %v", err)
 	}
 	return &tursoDB{db}