Create generalized todo module (#982)

* Create generalized todo module

Makes existing modules "backends"
This gives us a consistent interface

* Fix check issues

* Fix lint errors

* Make changes to stay on wtfutil todoist fork

modules/todo_plus/backend/backend.go

@@ -0,0 +1,16 @@
+package backend
+
+import (
+	"github.com/olebedev/config"
+)
+
+type Backend interface {
+	Title() string
+	Setup(*config.Config)
+	BuildProjects() []*Project
+	GetProject(string) *Project
+	LoadTasks(string) ([]Task, error)
+	CloseTask(*Task) error
+	DeleteTask(*Task) error
+	Sources() []string
+}

modules/todo_plus/backend/project.go

@@ -0,0 +1,66 @@
+package backend
+
+type Task struct {
+	ID        string
+	Completed bool
+	Name      string
+}
+
+type Project struct {
+	ID   string
+	Name string
+
+	Index   int
+	Tasks   []Task
+	Err     error
+	backend Backend
+}
+
+func (proj *Project) IsLast() bool {
+	return proj.Index >= len(proj.Tasks)-1
+}
+
+func (proj *Project) loadTasks() {
+	Tasks, err := proj.backend.LoadTasks(proj.ID)
+	proj.Err = err
+	proj.Tasks = Tasks
+}
+
+func (proj *Project) LongestLine() int {
+	maxLen := 0
+
+	for _, task := range proj.Tasks {
+		if len(task.Name) > maxLen {
+			maxLen = len(task.Name)
+		}
+	}
+
+	return maxLen
+}
+
+func (proj *Project) currentTask() *Task {
+	if proj.Index < 0 {
+		return nil
+	}
+
+	return &proj.Tasks[proj.Index]
+}
+
+func (proj *Project) CloseSelectedTask() {
+	currTask := proj.currentTask()
+
+	if currTask != nil {
+		_ = proj.backend.CloseTask(currTask)
+		proj.loadTasks()
+	}
+}
+
+func (proj *Project) DeleteSelectedTask() {
+	currTask := proj.currentTask()
+
+	if currTask != nil {
+		_ = proj.backend.DeleteTask(currTask)
+
+		proj.loadTasks()
+	}
+}

modules/todo_plus/backend/todoist.go

@@ -0,0 +1,108 @@
+package backend
+
+import (
+	"strconv"
+
+	"github.com/olebedev/config"
+	"github.com/wtfutil/todoist"
+)
+
+type Todoist struct {
+	projects []interface{}
+}
+
+func (todo *Todoist) Title() string {
+	return "Todoist"
+}
+
+func (todo *Todoist) Setup(config *config.Config) {
+	todoist.Token = config.UString("apiKey")
+	todo.projects = config.UList("projects")
+}
+
+func (todo *Todoist) BuildProjects() []*Project {
+	projects := []*Project{}
+
+	for _, id := range todo.projects {
+		i := strconv.Itoa(id.(int))
+		proj := todo.GetProject(i)
+		projects = append(projects, proj)
+	}
+	return projects
+}
+
+func (todo *Todoist) GetProject(id string) *Project {
+	// Todoist seems to experience a lot of network issues on their side
+	// If we can't connect, handle it with an empty project until we can
+	proj := &Project{
+		Index:   -1,
+		backend: todo,
+	}
+	i64, _ := strconv.ParseUint(id, 10, 32)
+	i := uint(i64)
+	project, err := todoist.GetProject(i)
+	if err != nil {
+		proj.Err = err
+		return proj
+	}
+
+	proj.ID = strconv.FormatUint(uint64(project.ID), 10)
+	proj.Name = project.Name
+
+	tasks, err := todo.LoadTasks(proj.ID)
+	proj.Err = err
+	proj.Tasks = tasks
+
+	return proj
+}
+
+func toTask(task todoist.Task) Task {
+	id := strconv.FormatUint(uint64(task.ID), 10)
+	return Task{
+		ID:        id,
+		Completed: task.Completed,
+		Name:      task.Content,
+	}
+}
+
+func (todo *Todoist) LoadTasks(id string) ([]Task, error) {
+	tasks, err := todoist.ListTask(todoist.QueryParam{"project_id": id})
+
+	if err != nil {
+		return nil, err
+	}
+	var finalTasks []Task
+	for _, item := range tasks {
+		finalTasks = append(finalTasks, toTask(item))
+	}
+	return finalTasks, nil
+}
+
+func (todo *Todoist) CloseTask(task *Task) error {
+	if task != nil {
+		i64, _ := strconv.ParseUint(task.ID, 10, 32)
+		i := uint(i64)
+		internal := todoist.Task{ID: i}
+		return internal.Close()
+	}
+	return nil
+}
+
+func (todo *Todoist) DeleteTask(task *Task) error {
+	if task != nil {
+		i64, _ := strconv.ParseUint(task.ID, 10, 32)
+		i := uint(i64)
+		internal := todoist.Task{ID: i}
+		return internal.Delete()
+	}
+	return nil
+}
+
+func (todo *Todoist) Sources() []string {
+	var result []string
+	for _, id := range todo.projects {
+		i := strconv.Itoa(id.(int))
+		result = append(result, i)
+	}
+	return result
+}

modules/todo_plus/backend/trello.go

@@ -0,0 +1,170 @@
+package backend
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/adlio/trello"
+	"github.com/olebedev/config"
+)
+
+type Trello struct {
+	username  string
+	boardName string
+	client    *trello.Client
+	board     string
+	projects  []interface{}
+}
+
+func (todo *Trello) Title() string {
+	return "Trello"
+}
+
+func (todo *Trello) Setup(config *config.Config) {
+	todo.username = config.UString("username")
+	todo.boardName = config.UString("board")
+	todo.client = trello.NewClient(
+		config.UString("apiKey"),
+		config.UString("accessToken"),
+	)
+	board, err := getBoardID(todo.client, todo.username, todo.boardName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	todo.board = board
+	todo.projects = config.UList("lists")
+}
+
+func getBoardID(client *trello.Client, username, boardName string) (string, error) {
+	member, err := client.GetMember(username, trello.Defaults())
+	if err != nil {
+		return "", err
+	}
+
+	boards, err := member.GetBoards(trello.Defaults())
+	if err != nil {
+		return "", err
+	}
+
+	for _, board := range boards {
+		if board.Name == boardName {
+			return board.ID, nil
+		}
+	}
+
+	return "", fmt.Errorf("could not find board with name %s", boardName)
+}
+
+func getListId(client *trello.Client, boardID string, listName string) (string, error) {
+	board, err := client.GetBoard(boardID, trello.Defaults())
+	if err != nil {
+		return "", err
+	}
+
+	boardLists, err := board.GetLists(trello.Defaults())
+	if err != nil {
+		return "", err
+	}
+
+	for _, list := range boardLists {
+		if list.Name == listName {
+			return list.ID, nil
+		}
+	}
+
+	return "", nil
+}
+
+func getCardsOnList(client *trello.Client, listID string) ([]*trello.Card, error) {
+	list, err := client.GetList(listID, trello.Defaults())
+	if err != nil {
+		return nil, err
+	}
+
+	cards, err := list.GetCards(trello.Defaults())
+	if err != nil {
+		return nil, err
+	}
+
+	return cards, nil
+}
+
+func (todo *Trello) BuildProjects() []*Project {
+	projects := []*Project{}
+
+	for _, id := range todo.projects {
+		proj := todo.GetProject(id.(string))
+		projects = append(projects, proj)
+	}
+	return projects
+}
+
+func (todo *Trello) GetProject(id string) *Project {
+	proj := &Project{
+		Index:   -1,
+		backend: todo,
+	}
+
+	listId, err := getListId(todo.client, todo.board, id)
+	if err != nil {
+		proj.Err = err
+		return proj
+	}
+	proj.ID = listId
+	proj.Name = id
+
+	tasks, err := todo.LoadTasks(listId)
+	proj.Err = err
+	proj.Tasks = tasks
+
+	return proj
+}
+
+func fromTrello(task *trello.Card) Task {
+	return Task{
+		ID:        task.ID,
+		Completed: task.Closed,
+		Name:      task.Name,
+	}
+}
+
+func (todo *Trello) LoadTasks(id string) ([]Task, error) {
+	tasks, err := getCardsOnList(todo.client, id)
+
+	if err != nil {
+		return nil, err
+	}
+	var finalTasks []Task
+	for _, item := range tasks {
+		finalTasks = append(finalTasks, fromTrello(item))
+	}
+	return finalTasks, nil
+}
+
+func (todo *Trello) CloseTask(task *Task) error {
+	args := trello.Arguments{
+		"closed": "true",
+	}
+	if task != nil {
+		// Card has an internal client rep which we can't access
+		// Just force a lookup
+		internal, err := todo.client.GetCard(task.ID, trello.Arguments{})
+		if err != nil {
+			return err
+		}
+		return internal.Update(args)
+	}
+	return nil
+}
+
+func (todo *Trello) DeleteTask(task *Task) error {
+	return nil
+}
+
+func (todo *Trello) Sources() []string {
+	var result []string
+	for _, id := range todo.projects {
+		result = append(result, id.(string))
+	}
+	return result
+}

modules/todo_plus/display.go

@@ -0,0 +1,43 @@
+package todo_plus
+
+import (
+	"fmt"
+
+	"github.com/rivo/tview"
+	"github.com/wtfutil/wtf/utils"
+)
+
+func (widget *Widget) content() (string, string, bool) {
+	proj := widget.CurrentProject()
+
+	if proj == nil {
+		return widget.CommonSettings().Title, "", false
+	}
+
+	if proj.Err != nil {
+		return widget.CommonSettings().Title, proj.Err.Error(), true
+	}
+
+	title := fmt.Sprintf(
+		"[%s]%s[white]",
+		widget.settings.common.Colors.TextTheme.Title,
+		proj.Name)
+
+	str := ""
+
+	for idx, item := range proj.Tasks {
+		row := fmt.Sprintf(
+			`[%s]| | %s[%s]`,
+			widget.RowColor(idx),
+			tview.Escape(item.Name),
+			widget.RowColor(idx),
+		)
+
+		str += utils.HighlightableHelper(widget.View, row, idx, len(item.Name))
+	}
+	return title, str, false
+}
+
+func (widget *Widget) display() {
+	widget.ScrollableWidget.Redraw(widget.content)
+}

modules/todo_plus/keyboard.go

@@ -0,0 +1,21 @@
+package todo_plus
+
+import "github.com/gdamore/tcell"
+
+func (widget *Widget) initializeKeyboardControls() {
+	widget.InitializeCommonControls(widget.Refresh)
+
+	widget.SetKeyboardChar("d", widget.Delete, "Delete item")
+	widget.SetKeyboardChar("j", widget.Prev, "Select previous item")
+	widget.SetKeyboardChar("k", widget.Next, "Select next item")
+	widget.SetKeyboardChar("h", widget.PrevSource, "Select previous project")
+	widget.SetKeyboardChar("c", widget.Close, "Close item")
+	widget.SetKeyboardChar("l", widget.NextSource, "Select next project")
+	widget.SetKeyboardChar("u", widget.Unselect, "Clear selection")
+
+	widget.SetKeyboardKey(tcell.KeyDown, widget.Next, "Select next item")
+	widget.SetKeyboardKey(tcell.KeyUp, widget.Prev, "Select previous item")
+	widget.SetKeyboardKey(tcell.KeyEsc, widget.Unselect, "Clear selection")
+	widget.SetKeyboardKey(tcell.KeyLeft, widget.PrevSource, "Select previous project")
+	widget.SetKeyboardKey(tcell.KeyRight, widget.NextSource, "Select next project")
+}

modules/todo_plus/settings.go

@@ -0,0 +1,81 @@
+package todo_plus
+
+import (
+	"os"
+
+	"github.com/olebedev/config"
+	"github.com/wtfutil/wtf/cfg"
+)
+
+const (
+	defaultTitle     = "Todo"
+	defaultFocusable = true
+)
+
+type Settings struct {
+	common *cfg.Common
+
+	backendType     string
+	backendSettings *config.Config
+}
+
+func NewSettingsFromYAML(name string, ymlConfig *config.Config, globalConfig *config.Config) *Settings {
+
+	backend, _ := ymlConfig.Get("backendSettings")
+
+	settings := Settings{
+		common: cfg.NewCommonSettingsFromModule(name, defaultTitle, defaultFocusable, ymlConfig, globalConfig),
+
+		backendType:     ymlConfig.UString("backendType"),
+		backendSettings: backend,
+	}
+
+	return &settings
+}
+
+func FromTodoist(name string, ymlConfig *config.Config, globalConfig *config.Config) *Settings {
+	apiKey := ymlConfig.UString("apiKey", ymlConfig.UString("apikey", os.Getenv("WTF_TODOIST_TOKEN")))
+	cfg.ModuleSecret(name, globalConfig, &apiKey).Load()
+	projects := ymlConfig.UList("projects")
+	backend, _ := config.ParseYaml("apiKey: " + apiKey)
+	_ = backend.Set(".projects", projects)
+
+	settings := Settings{
+		common: cfg.NewCommonSettingsFromModule(name, defaultTitle, defaultFocusable, ymlConfig, globalConfig),
+
+		backendType:     "todoist",
+		backendSettings: backend,
+	}
+
+	return &settings
+}
+
+func FromTrello(name string, ymlConfig *config.Config, globalConfig *config.Config) *Settings {
+
+	accessToken := ymlConfig.UString("accessToken", ymlConfig.UString("apikey", os.Getenv("WTF_TRELLO_ACCESS_TOKEN")))
+	apiKey := ymlConfig.UString("apiKey", os.Getenv("WTF_TRELLO_API_KEY"))
+	cfg.ModuleSecret(name, globalConfig, &apiKey).Load()
+	board := ymlConfig.UString("board")
+	username := ymlConfig.UString("username")
+	var lists []interface{}
+	list, err := ymlConfig.String("list")
+	if err == nil {
+		lists = append(lists, list)
+	} else {
+		lists = ymlConfig.UList("list")
+	}
+	backend, _ := config.ParseYaml("apiKey: " + apiKey)
+	_ = backend.Set(".accessToken", accessToken)
+	_ = backend.Set(".board", board)
+	_ = backend.Set(".username", username)
+	_ = backend.Set(".lists", lists)
+
+	settings := Settings{
+		common: cfg.NewCommonSettingsFromModule(name, defaultTitle, defaultFocusable, ymlConfig, globalConfig),
+
+		backendType:     "trello",
+		backendSettings: backend,
+	}
+
+	return &settings
+}

modules/todo_plus/widget.go

@@ -0,0 +1,145 @@
+package todo_plus
+
+import (
+	"log"
+
+	"github.com/rivo/tview"
+	"github.com/wtfutil/wtf/modules/todo_plus/backend"
+	"github.com/wtfutil/wtf/view"
+)
+
+// A Widget represents a Todoist widget
+type Widget struct {
+	view.KeyboardWidget
+	view.MultiSourceWidget
+	view.ScrollableWidget
+
+	projects []*backend.Project
+	settings *Settings
+	backend  backend.Backend
+}
+
+// NewWidget creates a new instance of a widget
+func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget {
+	widget := Widget{
+		KeyboardWidget:    view.NewKeyboardWidget(app, pages, settings.common),
+		MultiSourceWidget: view.NewMultiSourceWidget(settings.common, "project", "projects"),
+		ScrollableWidget:  view.NewScrollableWidget(app, settings.common),
+
+		settings: settings,
+	}
+
+	widget.backend = getBackend(settings.backendType)
+	widget.backend.Setup(settings.backendSettings)
+	widget.CommonSettings().Title = widget.backend.Title()
+
+	widget.SetRenderFunction(widget.display)
+	widget.initializeKeyboardControls()
+	widget.View.SetInputCapture(widget.InputCapture)
+	widget.SetDisplayFunction(widget.display)
+
+	widget.KeyboardWidget.SetView(widget.View)
+
+	return &widget
+}
+
+func getBackend(backendType string) backend.Backend {
+	switch backendType {
+	case "trello":
+		backend := &backend.Trello{}
+		return backend
+	case "todoist":
+		backend := &backend.Todoist{}
+		return backend
+	default:
+		log.Fatal(backendType + " is not a supported backend")
+		return nil
+	}
+
+}
+
+/* -------------------- Exported Functions -------------------- */
+
+func (widget *Widget) CurrentProject() *backend.Project {
+	return widget.ProjectAt(widget.Idx)
+}
+
+func (widget *Widget) ProjectAt(idx int) *backend.Project {
+	if len(widget.projects) == 0 {
+		return nil
+	}
+
+	return widget.projects[idx]
+}
+
+func (widget *Widget) Refresh() {
+	if widget.Disabled() {
+		return
+	}
+
+	widget.projects = widget.backend.BuildProjects()
+	widget.Sources = widget.backend.Sources()
+	widget.SetItemCount(len(widget.CurrentProject().Tasks))
+	widget.display()
+}
+
+func (widget *Widget) HelpText() string {
+	return widget.KeyboardWidget.HelpText()
+}
+
+func (widget *Widget) NextSource() {
+	widget.MultiSourceWidget.NextSource()
+	widget.Selected = widget.CurrentProject().Index
+	widget.SetItemCount(len(widget.CurrentProject().Tasks))
+	widget.RenderFunction()
+}
+
+func (widget *Widget) PrevSource() {
+	widget.MultiSourceWidget.PrevSource()
+	widget.Selected = widget.CurrentProject().Index
+	widget.SetItemCount(len(widget.CurrentProject().Tasks))
+	widget.RenderFunction()
+}
+
+func (widget *Widget) Prev() {
+	widget.ScrollableWidget.Prev()
+	widget.CurrentProject().Index = widget.Selected
+}
+
+func (widget *Widget) Next() {
+	widget.ScrollableWidget.Next()
+	widget.CurrentProject().Index = widget.Selected
+}
+
+func (widget *Widget) Unselect() {
+	widget.ScrollableWidget.Unselect()
+	widget.CurrentProject().Index = -1
+	widget.RenderFunction()
+}
+
+/* -------------------- Keyboard Movement -------------------- */
+
+// Close closes the currently-selected task in the currently-selected project
+func (w *Widget) Close() {
+	w.CurrentProject().CloseSelectedTask()
+	w.SetItemCount(len(w.CurrentProject().Tasks))
+
+	if w.CurrentProject().IsLast() {
+		w.Prev()
+		return
+	}
+	w.CurrentProject().Index = w.Selected
+	w.RenderFunction()
+}
+
+// Delete deletes the currently-selected task in the currently-selected project
+func (w *Widget) Delete() {
+	w.CurrentProject().DeleteSelectedTask()
+	w.SetItemCount(len(w.CurrentProject().Tasks))
+
+	if w.CurrentProject().IsLast() {
+		w.Prev()
+	}
+	w.CurrentProject().Index = w.Selected
+	w.RenderFunction()
+}