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
+}