2023-05-06 12:49:40 +01:00
|
|
|
package ui
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
|
|
|
|
"codeflow.dananglin.me.uk/apollo/pelican/internal/board"
|
2024-01-08 04:52:13 +00:00
|
|
|
"github.com/gdamore/tcell/v2"
|
2023-05-06 12:49:40 +01:00
|
|
|
"github.com/rivo/tview"
|
|
|
|
)
|
|
|
|
|
2024-01-09 15:51:23 +00:00
|
|
|
type (
|
|
|
|
boardMovement int
|
|
|
|
boardMode int
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
next boardMovement = iota
|
|
|
|
previous
|
|
|
|
)
|
|
|
|
|
2023-05-06 12:49:40 +01:00
|
|
|
const (
|
2024-01-09 15:51:23 +00:00
|
|
|
normal boardMode = iota
|
|
|
|
selection
|
2023-05-06 12:49:40 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2024-01-10 18:21:14 +00:00
|
|
|
mainPage string = "main"
|
|
|
|
quitPage string = "quit"
|
2024-01-12 12:33:18 +00:00
|
|
|
cardFormPage string = "card form"
|
2024-01-10 18:21:14 +00:00
|
|
|
deleteCardModalPage string = "delete card modal"
|
2024-01-12 15:07:42 +00:00
|
|
|
viewPage string = "view"
|
2023-05-06 12:49:40 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
type UI struct {
|
|
|
|
*tview.Application
|
|
|
|
|
2024-01-08 04:52:13 +00:00
|
|
|
columns []*column
|
2023-05-06 12:49:40 +01:00
|
|
|
flex *tview.Flex
|
|
|
|
pages *tview.Pages
|
|
|
|
focusedColumn int
|
|
|
|
board board.Board
|
2024-01-09 15:51:23 +00:00
|
|
|
mode boardMode
|
2023-05-06 12:49:40 +01:00
|
|
|
quitModal *tview.Modal
|
2024-01-12 12:33:18 +00:00
|
|
|
cardForm *cardForm
|
2023-05-06 12:49:40 +01:00
|
|
|
deleteCardModal *tview.Modal
|
2024-01-09 15:51:23 +00:00
|
|
|
statusSelection statusSelection
|
2024-01-12 15:07:42 +00:00
|
|
|
view *cardView
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewUI returns a new UI value.
|
2023-12-12 12:47:58 +00:00
|
|
|
func NewUI(path string) (UI, error) {
|
2024-01-09 15:51:23 +00:00
|
|
|
kanban, err := board.Open(path)
|
2023-12-12 12:47:58 +00:00
|
|
|
if err != nil {
|
|
|
|
return UI{}, fmt.Errorf("unable to open the project's board; %w", err)
|
|
|
|
}
|
|
|
|
|
2024-01-09 15:51:23 +00:00
|
|
|
userInterface := UI{
|
2023-05-06 12:49:40 +01:00
|
|
|
Application: tview.NewApplication(),
|
|
|
|
pages: tview.NewPages(),
|
|
|
|
flex: tview.NewFlex(),
|
|
|
|
quitModal: tview.NewModal(),
|
2024-01-12 12:33:18 +00:00
|
|
|
cardForm: newCardForm(),
|
2023-05-06 12:49:40 +01:00
|
|
|
focusedColumn: 0,
|
|
|
|
columns: nil,
|
2024-01-09 15:51:23 +00:00
|
|
|
board: kanban,
|
2023-05-06 12:49:40 +01:00
|
|
|
deleteCardModal: tview.NewModal(),
|
2024-01-09 15:51:23 +00:00
|
|
|
mode: normal,
|
|
|
|
statusSelection: statusSelection{0, 0, 0},
|
2024-01-12 15:07:42 +00:00
|
|
|
view: newCardView(),
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
2024-01-09 15:51:23 +00:00
|
|
|
if err := userInterface.init(); err != nil {
|
2023-12-12 12:47:58 +00:00
|
|
|
return UI{}, fmt.Errorf("received an error after running the initialisation; %w", err)
|
|
|
|
}
|
2023-05-06 12:49:40 +01:00
|
|
|
|
2024-01-09 15:51:23 +00:00
|
|
|
return userInterface, nil
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// closeBoard closes the board.
|
|
|
|
func (u *UI) closeBoard() {
|
|
|
|
_ = u.board.Close()
|
|
|
|
}
|
|
|
|
|
2024-01-08 04:52:13 +00:00
|
|
|
// init initialises the UI.
|
|
|
|
func (u *UI) init() error {
|
|
|
|
err := u.initColumns()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("error initialising the status columns; %w", err)
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
2024-01-12 15:07:42 +00:00
|
|
|
u.flex.SetInputCapture(u.inputCapture())
|
|
|
|
|
|
|
|
u.pages.AddPage(mainPage, u.flex, true, true)
|
|
|
|
|
|
|
|
u.initQuitModal()
|
|
|
|
u.pages.AddPage(quitPage, u.quitModal, false, false)
|
|
|
|
|
|
|
|
u.initCardForm()
|
|
|
|
u.pages.AddPage(cardFormPage, u.cardForm, false, false)
|
|
|
|
|
|
|
|
u.initDeleteCardModal()
|
|
|
|
u.pages.AddPage(deleteCardModalPage, u.deleteCardModal, false, false)
|
|
|
|
|
|
|
|
u.initView()
|
|
|
|
u.pages.AddPage(viewPage, u.view, false, false)
|
|
|
|
|
|
|
|
u.SetRoot(u.pages, true)
|
|
|
|
|
|
|
|
if err := u.refresh(false); err != nil {
|
|
|
|
return fmt.Errorf("error refreshing the board; %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UI) inputCapture() func(event *tcell.EventKey) *tcell.EventKey {
|
|
|
|
return func(event *tcell.EventKey) *tcell.EventKey {
|
2024-01-08 04:52:13 +00:00
|
|
|
key, letter := event.Key(), event.Rune()
|
|
|
|
|
|
|
|
switch {
|
|
|
|
case letter == 'h' || key == tcell.KeyLeft:
|
2024-01-09 15:51:23 +00:00
|
|
|
u.shiftColumnFocus(previous)
|
2024-01-08 04:52:13 +00:00
|
|
|
case letter == 'l' || key == tcell.KeyRight:
|
2024-01-09 15:51:23 +00:00
|
|
|
u.shiftColumnFocus(next)
|
2024-01-10 11:20:15 +00:00
|
|
|
case letter == 'c':
|
2024-01-09 15:51:23 +00:00
|
|
|
if u.mode == normal {
|
2024-01-12 12:33:18 +00:00
|
|
|
u.cardForm.mode = create
|
|
|
|
u.cardForm.updateInputFields("", "")
|
|
|
|
u.cardForm.frame.SetTitle(" Create Card ")
|
|
|
|
u.pages.ShowPage(cardFormPage)
|
|
|
|
u.SetFocus(u.cardForm)
|
2024-01-09 15:51:23 +00:00
|
|
|
}
|
2024-01-08 04:52:13 +00:00
|
|
|
case letter == 'm':
|
2024-01-09 15:51:23 +00:00
|
|
|
if u.mode == normal {
|
2024-01-11 09:47:51 +00:00
|
|
|
u.statusSelection.cardID = u.focusedCardID()
|
|
|
|
u.statusSelection.currentStatusID = u.focusedStatusID()
|
2024-01-09 15:51:23 +00:00
|
|
|
u.mode = selection
|
|
|
|
}
|
2024-01-10 18:21:14 +00:00
|
|
|
case letter == 'e':
|
|
|
|
if u.mode == normal {
|
2024-01-12 12:33:18 +00:00
|
|
|
u.cardForm.mode = edit
|
2024-01-11 09:47:51 +00:00
|
|
|
card, _ := u.getFocusedCard()
|
2024-01-12 12:33:18 +00:00
|
|
|
u.cardForm.updateInputFields(card.Title, card.Description)
|
|
|
|
u.cardForm.frame.SetTitle(" Edit Card ")
|
|
|
|
u.pages.ShowPage(cardFormPage)
|
|
|
|
u.SetFocus(u.cardForm)
|
2024-01-10 18:21:14 +00:00
|
|
|
}
|
2024-01-08 04:52:13 +00:00
|
|
|
case key == tcell.KeyCtrlD:
|
2024-01-09 15:51:23 +00:00
|
|
|
if u.mode == normal {
|
2024-01-12 16:39:36 +00:00
|
|
|
card, _ := u.getFocusedCard()
|
|
|
|
text := fmt.Sprintf("Do you want to delete '%s'?", card.Title)
|
|
|
|
u.deleteCardModal.SetText(text)
|
2024-01-10 18:21:14 +00:00
|
|
|
u.pages.ShowPage(deleteCardModalPage)
|
2024-01-09 15:51:23 +00:00
|
|
|
u.SetFocus(u.deleteCardModal)
|
|
|
|
}
|
2024-01-08 04:52:13 +00:00
|
|
|
case key == tcell.KeyCtrlQ:
|
2024-01-09 15:51:23 +00:00
|
|
|
if u.mode == normal {
|
|
|
|
u.pages.ShowPage(quitPage)
|
|
|
|
u.SetFocus(u.quitModal)
|
|
|
|
}
|
|
|
|
case key == tcell.KeyESC:
|
|
|
|
if u.mode != normal {
|
|
|
|
u.mode = normal
|
|
|
|
}
|
|
|
|
case key == tcell.KeyEnter:
|
2024-01-12 15:07:42 +00:00
|
|
|
switch u.mode {
|
|
|
|
case normal:
|
|
|
|
card, _ := u.getFocusedCard()
|
|
|
|
status := u.focusedStatusName()
|
|
|
|
u.view.print(card.ID, card.Title, status, card.Created, card.Description)
|
|
|
|
u.pages.ShowPage(viewPage)
|
|
|
|
u.SetFocus(u.view)
|
|
|
|
case selection:
|
2024-01-11 09:47:51 +00:00
|
|
|
u.statusSelection.nextStatusID = u.focusedStatusID()
|
2024-01-09 15:51:23 +00:00
|
|
|
if u.statusSelection.currentStatusID != u.statusSelection.nextStatusID {
|
|
|
|
u.statusSelection.moveCard(u.board)
|
|
|
|
}
|
2024-01-12 15:07:42 +00:00
|
|
|
|
2024-01-09 15:51:23 +00:00
|
|
|
u.statusSelection = statusSelection{0, 0, 0}
|
|
|
|
u.mode = normal
|
|
|
|
_ = u.refresh(false)
|
|
|
|
}
|
2024-01-08 04:52:13 +00:00
|
|
|
}
|
2023-05-06 12:49:40 +01:00
|
|
|
|
2024-01-08 04:52:13 +00:00
|
|
|
return event
|
2023-12-12 12:47:58 +00:00
|
|
|
}
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
2024-01-12 12:33:18 +00:00
|
|
|
// initCardForm initialises the card form.
|
|
|
|
func (u *UI) initCardForm() {
|
|
|
|
doneFunc := func(title, description string, success bool, mode cardFormMode) {
|
2023-05-06 12:49:40 +01:00
|
|
|
if success {
|
2024-01-10 18:21:14 +00:00
|
|
|
switch mode {
|
|
|
|
case create:
|
|
|
|
_ = u.newCard(title, description)
|
|
|
|
case edit:
|
2024-01-11 09:47:51 +00:00
|
|
|
_ = u.editFocusedCard(title, description)
|
2024-01-10 18:21:14 +00:00
|
|
|
}
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
2024-01-12 12:33:18 +00:00
|
|
|
u.pages.HidePage(cardFormPage)
|
2023-05-06 12:49:40 +01:00
|
|
|
u.setColumnFocus()
|
|
|
|
}
|
|
|
|
|
2024-01-12 12:33:18 +00:00
|
|
|
u.cardForm.setDoneFunc(doneFunc)
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// initDeleteCardModal initialises the modal for deleting cards.
|
|
|
|
func (u *UI) initDeleteCardModal() {
|
|
|
|
doneFunc := func(_ int, buttonLabel string) {
|
|
|
|
if buttonLabel == "Confirm" {
|
2024-01-11 09:47:51 +00:00
|
|
|
u.deleteFocusedCard()
|
2024-01-09 15:51:23 +00:00
|
|
|
_ = u.refresh(true)
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
2024-01-10 18:21:14 +00:00
|
|
|
u.pages.HidePage(deleteCardModalPage)
|
2023-05-06 12:49:40 +01:00
|
|
|
u.setColumnFocus()
|
|
|
|
}
|
|
|
|
|
2024-01-12 16:39:36 +00:00
|
|
|
u.deleteCardModal.AddButtons([]string{"Confirm", "Cancel"}).SetDoneFunc(doneFunc)
|
|
|
|
|
|
|
|
u.deleteCardModal.SetBorder(true).SetBorderColor(tcell.ColorOrangeRed)
|
|
|
|
u.deleteCardModal.SetBackgroundColor(tcell.ColorBlack.TrueColor())
|
|
|
|
u.deleteCardModal.SetButtonBackgroundColor(tcell.ColorBlueViolet.TrueColor())
|
|
|
|
u.deleteCardModal.SetTextColor(tcell.ColorWhite.TrueColor())
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// initQuitModal initialises the quit modal.
|
|
|
|
func (u *UI) initQuitModal() {
|
|
|
|
doneFunc := func(_ int, buttonLabel string) {
|
|
|
|
switch buttonLabel {
|
|
|
|
case "Quit":
|
|
|
|
u.shutdown()
|
|
|
|
default:
|
2024-01-08 04:52:13 +00:00
|
|
|
u.pages.HidePage(quitPage)
|
2023-05-06 12:49:40 +01:00
|
|
|
u.setColumnFocus()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u.quitModal.SetText("Do you want to quit the application?").
|
|
|
|
AddButtons([]string{"Quit", "Cancel"}).
|
|
|
|
SetDoneFunc(doneFunc)
|
|
|
|
}
|
|
|
|
|
2024-01-12 15:07:42 +00:00
|
|
|
// initView initialises the view window for displaying the card.
|
|
|
|
func (u *UI) initView() {
|
|
|
|
doneFunc := func(key tcell.Key) {
|
|
|
|
if key == tcell.KeyEsc {
|
|
|
|
u.pages.HidePage(viewPage)
|
|
|
|
u.view.Clear()
|
|
|
|
u.setColumnFocus()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u.view.setDoneFunc(doneFunc)
|
|
|
|
}
|
|
|
|
|
2023-05-06 12:49:40 +01:00
|
|
|
// newCard creates and saves a new card to the database.
|
2024-01-10 18:21:14 +00:00
|
|
|
func (u *UI) newCard(title, description string) error {
|
2023-05-06 12:49:40 +01:00
|
|
|
args := board.CardArgs{
|
2024-01-10 18:21:14 +00:00
|
|
|
NewTitle: title,
|
|
|
|
NewDescription: description,
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := u.board.CreateCard(args); err != nil {
|
|
|
|
return fmt.Errorf("unable to create card, %w", err)
|
|
|
|
}
|
|
|
|
|
2024-01-09 15:51:23 +00:00
|
|
|
_ = u.refresh(false)
|
2024-01-08 04:52:13 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-01-11 09:47:51 +00:00
|
|
|
// editFocusedCard saves and edited card to the database.
|
|
|
|
func (u *UI) editFocusedCard(title, description string) error {
|
|
|
|
cardID := u.focusedCardID()
|
|
|
|
|
2024-01-10 18:21:14 +00:00
|
|
|
args := board.UpdateCardArgs{
|
|
|
|
CardID: cardID,
|
|
|
|
CardArgs: board.CardArgs{
|
|
|
|
NewTitle: title,
|
|
|
|
NewDescription: description,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := u.board.UpdateCard(args); err != nil {
|
|
|
|
return fmt.Errorf("unable to edit card with ID: %d; %w", cardID, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
_ = u.refresh(true)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-01-11 09:47:51 +00:00
|
|
|
// getFocusedCard retrieves the details of the focused card.
|
|
|
|
func (u *UI) getFocusedCard() (board.Card, error) {
|
|
|
|
cardID := u.focusedCardID()
|
|
|
|
|
|
|
|
card, err := u.board.Card(cardID)
|
|
|
|
if err != nil {
|
|
|
|
return board.Card{}, fmt.Errorf("unable to retrieve the card with card ID %d, %w", cardID, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return card, nil
|
|
|
|
}
|
2024-01-10 18:21:14 +00:00
|
|
|
|
2024-01-11 09:47:51 +00:00
|
|
|
// deleteFocusedCard deletes the focused card from the board.
|
|
|
|
func (u *UI) deleteFocusedCard() {
|
2024-01-10 18:21:14 +00:00
|
|
|
args := board.DeleteCardArgs{
|
2024-01-11 09:47:51 +00:00
|
|
|
CardID: u.focusedCardID(),
|
|
|
|
StatusID: u.focusedStatusID(),
|
2024-01-10 18:21:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_ = u.board.DeleteCard(args)
|
|
|
|
}
|
|
|
|
|
|
|
|
// initColumns initialises the columns of the Kanban board.
|
2024-01-08 04:52:13 +00:00
|
|
|
func (u *UI) initColumns() error {
|
|
|
|
u.flex.Clear()
|
|
|
|
|
|
|
|
statusList, err := u.board.StatusList()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("unable to retrieve the list of statuses; %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
columns := make([]*column, len(statusList))
|
|
|
|
|
|
|
|
for i := range statusList {
|
2024-01-09 15:51:23 +00:00
|
|
|
column := newColumn(statusList[i].ID, statusList[i].Name, u.boardMode)
|
2024-01-08 04:52:13 +00:00
|
|
|
u.flex.AddItem(column, 50, 1, true)
|
|
|
|
columns[i] = column
|
|
|
|
}
|
|
|
|
|
|
|
|
u.columns = columns
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UI) updateAllColumns() error {
|
|
|
|
for i := range u.columns {
|
|
|
|
if err := u.updateColumn(i); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UI) updateColumn(index int) error {
|
|
|
|
if err := u.columns[index].update(u.board); err != nil {
|
|
|
|
return fmt.Errorf("unable to update column; %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-01-09 15:51:23 +00:00
|
|
|
func (u *UI) shiftColumnFocus(movement boardMovement) {
|
|
|
|
switch movement {
|
|
|
|
case next:
|
2024-01-08 04:52:13 +00:00
|
|
|
if u.focusedColumn == len(u.columns)-1 {
|
|
|
|
u.focusedColumn = 0
|
|
|
|
} else {
|
|
|
|
u.focusedColumn++
|
|
|
|
}
|
2024-01-09 15:51:23 +00:00
|
|
|
case previous:
|
2024-01-08 04:52:13 +00:00
|
|
|
if u.focusedColumn == 0 {
|
|
|
|
u.focusedColumn = len(u.columns) - 1
|
|
|
|
} else {
|
|
|
|
u.focusedColumn--
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u.setColumnFocus()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UI) setColumnFocus() {
|
|
|
|
u.SetFocus(u.columns[u.focusedColumn])
|
|
|
|
}
|
|
|
|
|
|
|
|
// refresh refreshes the UI.
|
2024-01-09 15:51:23 +00:00
|
|
|
func (u *UI) refresh(updateFocusedColumnOnly bool) error {
|
2024-01-08 04:52:13 +00:00
|
|
|
if updateFocusedColumnOnly {
|
|
|
|
if err := u.updateColumn(u.focusedColumn); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if err := u.updateAllColumns(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u.setColumnFocus()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// shutdown shuts down the application.
|
|
|
|
func (u *UI) shutdown() {
|
|
|
|
u.closeBoard()
|
|
|
|
u.Stop()
|
2023-05-06 12:49:40 +01:00
|
|
|
}
|
2024-01-09 15:51:23 +00:00
|
|
|
|
2024-01-10 18:21:14 +00:00
|
|
|
// boardMode returns the current board mode.
|
2024-01-09 15:51:23 +00:00
|
|
|
func (u *UI) boardMode() boardMode {
|
|
|
|
return u.mode
|
|
|
|
}
|
2024-01-11 09:47:51 +00:00
|
|
|
|
|
|
|
// focusedCardID returns the ID of the card in focus.
|
|
|
|
func (u *UI) focusedCardID() int {
|
|
|
|
focusedCard := u.columns[u.focusedColumn].focusedCard
|
|
|
|
id := u.columns[u.focusedColumn].cards[focusedCard].id
|
|
|
|
|
|
|
|
return id
|
|
|
|
}
|
|
|
|
|
2024-01-12 15:07:42 +00:00
|
|
|
// focusedStatusID returns the ID of the status (column) in focus.
|
2024-01-11 09:47:51 +00:00
|
|
|
func (u *UI) focusedStatusID() int {
|
|
|
|
return u.columns[u.focusedColumn].statusID
|
|
|
|
}
|
2024-01-12 15:07:42 +00:00
|
|
|
|
|
|
|
// focusedStatusName returns the name of the status (column) in focus.
|
|
|
|
func (u *UI) focusedStatusName() string {
|
|
|
|
return u.columns[u.focusedColumn].statusName
|
|
|
|
}
|