127 lines
2.4 KiB
Go
127 lines
2.4 KiB
Go
package command
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
"git.ewintr.nl/gte/internal/configuration"
|
|
"git.ewintr.nl/gte/internal/process"
|
|
"git.ewintr.nl/gte/internal/storage"
|
|
"git.ewintr.nl/gte/internal/task"
|
|
"git.ewintr.nl/gte/pkg/mstore"
|
|
)
|
|
|
|
var (
|
|
ErrInitCommand = errors.New("could not initialize command")
|
|
ErrFailedCommand = errors.New("could not execute command")
|
|
)
|
|
|
|
type Result struct {
|
|
Message string
|
|
}
|
|
|
|
type Command interface {
|
|
Do() (Result, error)
|
|
}
|
|
|
|
func Parse(args []string, conf *configuration.Configuration) (Command, error) {
|
|
if len(args) == 0 {
|
|
return NewEmpty()
|
|
}
|
|
|
|
cmd, _ := args[0], args[1:]
|
|
switch cmd {
|
|
case "sync":
|
|
return NewSync(conf)
|
|
case "today":
|
|
return NewToday(conf)
|
|
default:
|
|
return NewEmpty()
|
|
}
|
|
}
|
|
|
|
type Empty struct{}
|
|
|
|
func NewEmpty() (*Empty, error) {
|
|
return &Empty{}, nil
|
|
}
|
|
|
|
func (cmd *Empty) Do() (Result, error) {
|
|
return Result{
|
|
Message: "did nothing\n",
|
|
}, nil
|
|
}
|
|
|
|
type Sync struct {
|
|
syncer *process.Sync
|
|
}
|
|
|
|
func NewSync(conf *configuration.Configuration) (*Sync, error) {
|
|
msgStore := mstore.NewIMAP(conf.IMAP())
|
|
remote := storage.NewRemoteRepository(msgStore)
|
|
local, err := storage.NewSqlite(conf.Sqlite())
|
|
if err != nil {
|
|
return &Sync{}, fmt.Errorf("%w: %v", ErrInitCommand, err)
|
|
}
|
|
syncer := process.NewSync(remote, local)
|
|
|
|
return &Sync{
|
|
syncer: syncer,
|
|
}, nil
|
|
}
|
|
|
|
func (s *Sync) Do() (Result, error) {
|
|
result, err := s.syncer.Process()
|
|
if err != nil {
|
|
return Result{}, fmt.Errorf("%w: %v", ErrFailedCommand, err)
|
|
}
|
|
|
|
return Result{
|
|
Message: fmt.Sprintf("synced %d tasks\n", result.Count),
|
|
}, nil
|
|
}
|
|
|
|
type Today struct {
|
|
local storage.LocalRepository
|
|
}
|
|
|
|
func NewToday(conf *configuration.Configuration) (*Today, error) {
|
|
local, err := storage.NewSqlite(conf.Sqlite())
|
|
if err != nil {
|
|
return &Today{}, fmt.Errorf("%w: %v", ErrInitCommand, err)
|
|
}
|
|
|
|
return &Today{
|
|
local: local,
|
|
}, nil
|
|
}
|
|
|
|
func (t *Today) Do() (Result, error) {
|
|
tasks, err := t.local.FindAllInFolder(task.FOLDER_PLANNED)
|
|
if err != nil {
|
|
return Result{}, fmt.Errorf("%w: %v", ErrFailedCommand, err)
|
|
}
|
|
|
|
todayTasks := []*task.Task{}
|
|
for _, t := range tasks {
|
|
if t.Due == task.Today || task.Today.After(t.Due) {
|
|
todayTasks = append(todayTasks, t)
|
|
}
|
|
}
|
|
|
|
if len(todayTasks) == 0 {
|
|
return Result{
|
|
Message: "nothing left",
|
|
}, nil
|
|
}
|
|
|
|
var msg string
|
|
for _, t := range todayTasks {
|
|
msg += fmt.Sprintf("%s - %s\n", t.Project, t.Action)
|
|
}
|
|
|
|
return Result{
|
|
Message: msg,
|
|
}, nil
|
|
}
|