139 lines
3.0 KiB
Go
139 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
timertxt "git.bullercodeworks.com/brian/go-timertxt"
|
|
)
|
|
|
|
func (a *AppState) opStatus(args []string) int {
|
|
fmt.Println("Current Time: " + time.Now().Format(time.Stamp))
|
|
if len(*a.TimerList.GetActiveTimers()) == 0 {
|
|
fmt.Println("No timers running")
|
|
return 0
|
|
}
|
|
for _, v := range *a.TimerList.GetActiveTimers() {
|
|
fmt.Println(timerToFriendlyString(&v))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (a *AppState) opListTimers(args []string) int {
|
|
// By default only list today
|
|
// Format:
|
|
// 2019/02/20 (9.25)
|
|
// start - end [ contexts ] [ projects ]
|
|
// ...
|
|
dayTotals := make(map[string]time.Duration)
|
|
for _, v := range *a.TimerList {
|
|
dur := v.FinishDate.Sub(v.StartDate)
|
|
if v.FinishDate.IsZero() {
|
|
dur = time.Now().Sub(v.StartDate)
|
|
}
|
|
dayTotals[v.StartDate.Format("2006/01/02")] += dur
|
|
}
|
|
var oldDayStr, dayStr string
|
|
for _, v := range *a.TimerList {
|
|
oldDayStr = dayStr
|
|
dayStr = v.StartDate.Format("2006/01/02")
|
|
if dayStr != oldDayStr {
|
|
wrkDur := dayTotals[dayStr].Round(GetRoundToDuration())
|
|
fmtStr := dayStr + " ( %.2f )\n"
|
|
fmt.Printf(fmtStr, DurationToDecimal(wrkDur))
|
|
}
|
|
|
|
fmt.Println(" " + timerToFriendlyString(&v))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (a *AppState) opStartTimer(args []string) int {
|
|
var contexts, projects []string
|
|
t := timertxt.NewTimer()
|
|
contexts, args = getContextsFromSlice(args)
|
|
projects, args = getProjectsFromSlice(args)
|
|
if len(args) > 0 {
|
|
if start, err := parseFuzzyTime(args[0]); err == nil {
|
|
t.StartDate = start
|
|
args = args[1:]
|
|
}
|
|
}
|
|
t.Contexts = contexts
|
|
t.Projects = projects
|
|
|
|
a.TimerList.AddTimer(t)
|
|
if err := a.WriteList(); err != nil {
|
|
fmt.Println(err.Error())
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (a *AppState) opStopTimer(args []string) int {
|
|
var err error
|
|
var wrk time.Time
|
|
end := time.Now()
|
|
id := -1
|
|
|
|
if len(args) > 0 {
|
|
if wrk, err = parseFuzzyTime(args[0]); err != nil {
|
|
id, err = strconv.Atoi(args[0])
|
|
} else {
|
|
end = wrk
|
|
args = args[1:]
|
|
}
|
|
}
|
|
fmt.Println("Stopping at : " + end.Format(time.RFC3339))
|
|
var timerIds []int
|
|
if id == -1 {
|
|
for _, v := range *a.TimerList.GetActiveTimers() {
|
|
timerIds = append(timerIds, v.Id)
|
|
}
|
|
} else {
|
|
timerIds = append(timerIds, id)
|
|
}
|
|
for _, v := range timerIds {
|
|
var stopped *timertxt.Timer
|
|
if stopped, err = a.TimerList.GetTimer(v); err != nil {
|
|
fmt.Println(err.Error())
|
|
}
|
|
if err = a.SetTimerFinished(v, end); err != nil {
|
|
fmt.Println(err.Error())
|
|
continue
|
|
}
|
|
fmt.Println("Stopped Timer:", timerToFriendlyString(stopped))
|
|
}
|
|
if err = a.WriteList(); err != nil {
|
|
fmt.Println(err.Error())
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (a *AppState) opState(args []string) int {
|
|
return 0
|
|
}
|
|
|
|
func (a *AppState) opFuzzyParse(args []string) int {
|
|
if len(args) > 0 {
|
|
if start, err := parseFuzzyTime(args[0]); err == nil {
|
|
fmt.Println(start.Format(time.RFC3339))
|
|
} else {
|
|
fmt.Println(err.Error())
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (a *AppState) opPrintUsage(args []string) int {
|
|
for _, v := range a.ValidOperations {
|
|
for _, vv := range v {
|
|
fmt.Println(" " + vv)
|
|
fmt.Println("")
|
|
}
|
|
}
|
|
return 0
|
|
}
|