315 lines
6.5 KiB
Go
315 lines
6.5 KiB
Go
/*
|
|
# Adding a new task
|
|
task-cli add "Buy groceries"
|
|
# Output: Task added successfully (ID: 1)
|
|
|
|
# Updating and deleting tasks
|
|
task-cli update 1 "Buy groceries and cook dinner"
|
|
task-cli delete 1
|
|
|
|
# Marking a task as in progress or done
|
|
task-cli mark-in-progress 1
|
|
task-cli mark-done 1
|
|
|
|
# Listing all tasks
|
|
task-cli list
|
|
|
|
# Listing tasks by status
|
|
task-cli list done
|
|
task-cli list todo
|
|
task-cli list in-progress
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type Task struct {
|
|
ID int `json:"id"`
|
|
Desc string `json:"description"`
|
|
Status string `json:"status"`
|
|
CreatedAt time.Time `json:"createdAt"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
}
|
|
|
|
const (
|
|
StatusTodo string = "todo"
|
|
StatusInProgress string = "in-progress"
|
|
StatusDone string = "done"
|
|
StatusAny string = "any"
|
|
)
|
|
|
|
func loadTasks(fileName string) ([]Task, error) {
|
|
if _, err := os.Stat(fileName); errors.Is(err, os.ErrNotExist) {
|
|
return []Task{}, nil
|
|
}
|
|
|
|
file, err := os.Open(fileName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
|
|
if stat, err := file.Stat(); err != nil || stat.Size() == 0 {
|
|
return []Task{}, nil
|
|
}
|
|
|
|
var tasks []Task
|
|
decoder := json.NewDecoder(file)
|
|
decoder.DisallowUnknownFields()
|
|
|
|
if err := decoder.Decode(&tasks); err != nil {
|
|
return nil, err
|
|
}
|
|
return tasks, nil
|
|
}
|
|
|
|
func saveAllTasks(fileName string, tasks []Task) error {
|
|
file, err := os.Create(fileName)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
encoder := json.NewEncoder(file)
|
|
encoder.SetIndent("", " ")
|
|
return encoder.Encode(tasks)
|
|
}
|
|
|
|
func appendToTasks(fileName string, task Task) error {
|
|
tasks, err := loadTasks(fileName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := range tasks {
|
|
if task.ID == tasks[i].ID || task.Desc == tasks[i].Desc {
|
|
return fmt.Errorf("err: duplicated keys")
|
|
}
|
|
}
|
|
|
|
tasks = append(tasks, task)
|
|
|
|
return saveAllTasks(fileName, tasks)
|
|
|
|
}
|
|
|
|
func addTask(fileName string, opts []string) (Task, error) {
|
|
var task Task
|
|
var err error
|
|
|
|
tasks, err := loadTasks(fileName)
|
|
if err != nil {
|
|
return task, err
|
|
}
|
|
|
|
if len(tasks) == 0 {
|
|
task.ID = 1
|
|
} else {
|
|
task.ID = tasks[len(tasks)-1].ID + 1
|
|
}
|
|
task.CreatedAt = time.Now()
|
|
task.UpdatedAt = time.Now()
|
|
task.Status = StatusTodo
|
|
|
|
if opts != nil {
|
|
task.Desc = opts[0]
|
|
fmt.Printf("Task added successfully (ID: %d)", task.ID)
|
|
} else {
|
|
return task, fmt.Errorf("err: opts is nil")
|
|
}
|
|
|
|
return task, err
|
|
}
|
|
|
|
func listTasks(fileName string, status string, verbose bool) error {
|
|
tasks, err := loadTasks(fileName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := range tasks {
|
|
cy, cm, cd := tasks[i].CreatedAt.Date()
|
|
uy, um, ud := tasks[i].UpdatedAt.Date()
|
|
if status == StatusTodo && tasks[i].Status == StatusTodo {
|
|
if verbose {
|
|
fmt.Printf("(ID: %d, %s): %s, created (%d %s, %d) and modified (%d %s, %d)\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc, cd, cm, cy, ud, um, uy)
|
|
} else {
|
|
fmt.Printf("(ID: %d, %s): %s\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc)
|
|
}
|
|
continue
|
|
}
|
|
if status == StatusDone && tasks[i].Status == StatusDone {
|
|
if verbose {
|
|
fmt.Printf("(ID: %d, %s): %s, created (%d %s, %d) and modified (%d %s, %d)\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc, cd, cm, cy, ud, um, uy)
|
|
} else {
|
|
fmt.Printf("(ID: %d, %s): %s\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc)
|
|
}
|
|
continue
|
|
}
|
|
if status == StatusInProgress && tasks[i].Status == StatusInProgress {
|
|
if verbose {
|
|
fmt.Printf("(ID: %d, %s): %s, created (%d %s, %d) and modified (%d %s, %d)\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc, cd, cm, cy, ud, um, uy)
|
|
} else {
|
|
fmt.Printf("(ID: %d, %s): %s\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc)
|
|
}
|
|
continue
|
|
}
|
|
if status == StatusAny {
|
|
if verbose {
|
|
fmt.Printf("(ID: %d, %s): %s, created (%d %s, %d) and modified (%d %s, %d)\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc, cd, cm, cy, ud, um, uy)
|
|
} else {
|
|
fmt.Printf("(ID: %d, %s): %s\n", tasks[i].ID, tasks[i].Status, tasks[i].Desc)
|
|
}
|
|
continue
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func mark(fileName string, idx int, status string) error {
|
|
tasks, err := loadTasks(fileName)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
i := slices.IndexFunc(tasks, func(t Task) bool {
|
|
return t.ID == idx
|
|
})
|
|
|
|
if i != -1 {
|
|
tasks[i].Status = status
|
|
tasks[i].UpdatedAt = time.Now()
|
|
}
|
|
|
|
saveAllTasks(fileName, tasks)
|
|
|
|
return nil
|
|
}
|
|
|
|
func delete(fileName string, idx int) error {
|
|
tasks, err := loadTasks(fileName)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
i := slices.IndexFunc(tasks, func(t Task) bool {
|
|
return t.ID == idx
|
|
})
|
|
|
|
if i != -1 {
|
|
tasks = slices.Delete(tasks, i, i+1)
|
|
}
|
|
|
|
saveAllTasks(fileName, tasks)
|
|
return nil
|
|
}
|
|
|
|
func update(fileName string, desc string, idx int) error {
|
|
tasks, err := loadTasks(fileName)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
i := slices.IndexFunc(tasks, func(t Task) bool {
|
|
return t.ID == idx
|
|
})
|
|
|
|
if i != -1 {
|
|
tasks[i].Desc = desc
|
|
}
|
|
|
|
saveAllTasks(fileName, tasks)
|
|
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
args := os.Args[1:]
|
|
fileName := "tasks.json"
|
|
var verbose bool
|
|
|
|
for i := range args {
|
|
if args[i] == "-v" {
|
|
verbose = true
|
|
}
|
|
}
|
|
|
|
if args[0] == "add" {
|
|
task, err := addTask(fileName, args[1:])
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
appendToTasks(fileName, task)
|
|
}
|
|
|
|
if args[0] == "list" {
|
|
if len(args) > 1 {
|
|
if args[1] == "todo" {
|
|
err := listTasks(fileName, StatusTodo, verbose)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
} else if args[1] == "done" {
|
|
err := listTasks(fileName, StatusDone, verbose)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
} else if args[1] == "in-progress" {
|
|
err := listTasks(fileName, StatusInProgress, verbose)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
} else {
|
|
err := listTasks(fileName, StatusAny, verbose)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
} else {
|
|
err := listTasks(fileName, StatusAny, verbose)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
} else if args[0] == "mark-in-progress" {
|
|
idx, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
err = mark(fileName, idx, StatusInProgress)
|
|
} else if args[0] == "mark-done" {
|
|
str, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
err = mark(fileName, str, StatusDone)
|
|
} else if args[0] == "delete" {
|
|
idx, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
err = delete(fileName, idx)
|
|
} else if args[0] == "update" {
|
|
idx, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
err = update(fileName, strings.Join(args[2:], " "), idx)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
} else {
|
|
fmt.Printf("Invalid arguments: %s", args[0])
|
|
}
|
|
|
|
}
|