gime/timer_ops.go

package main

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	timertxt "git.bullercodeworks.com/brian/go-timertxt"
)

func (a *AppState) opStatus(args []string) int {
	if len(*a.TimerList.GetActiveTimers()) == 0 {
		fmt.Println("No timers running")
		return 0
	}
	var currDur time.Duration
	for _, v := range *a.TimerList {
		if v.ActiveToday() {
			currDur += v.Duration()
		}
	}
	d := currDur.Round(GetRoundToDuration())
	fmt.Printf("%s ( %.2f hrs )\n", time.Now().Format(time.Stamp), DurationToDecimal(d))
	for _, v := range *a.TimerList.GetActiveTimers() {
		fmt.Println(timerToFriendlyString(&v))
	}
	return 0
}

/**
 * List timers for a given time span
 * By default, only list Today
 */
func (a *AppState) opListTimers(args []string) int {
	var start, end time.Time
	var err error

	if len(args) > 0 {
		if args[0] == "--a" {
			start = time.Time{}
			end = time.Now()
			args = args[1:]
		} else {
			if start, err = parseFuzzyTime(args[0]); err != nil {
				y, m, d := time.Now().Date()
				start = time.Date(y, m, d, 0, 0, 0, 0, time.Now().Location())
			} else {
				args = args[1:]
			}
			if end, err = parseFuzzyTime(args[0]); err != nil {
				y, m, d := time.Now().Date()
				end = time.Date(y, m, d, 23, 59, 59, 0, time.Now().Location())
			} else {
				args = args[1:]
			}
		}
	}

	list := a.TimerList.GetTimersInRange(start, end)
	dayTotals := make(map[string]time.Duration)
	for _, v := range *list {
		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 *list {
		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:]
		}
	}
	for _, v := range contexts {
		t.Contexts = append(t.Contexts, strings.TrimPrefix(v, "@"))
	}
	for _, v := range projects {
		t.Projects = append(t.Projects, strings.TrimPrefix(v, "+"))
	}

	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) opSwitchTimer(args []string) int {
	return 0
}

func (a *AppState) opArchiveTimer(args []string) int {
	if len(args) > 0 {
		for _, v := range args {
			var id int
			var timer *timertxt.Timer
			var err error
			if id, err = strconv.Atoi(v); err != nil {
				fmt.Printf("Invalid id given: %s\n", v)
				return 1
			}
			if timer, err = a.TimerList.GetTimer(id); err != nil {
				fmt.Printf("Error getting timer %d\n", id)
				return 1
			}
			if err = a.archiveTimer(id); err != nil {
				fmt.Printf("Error archiving timer %d\n", id)
				return 1
			}
			fmt.Println(a.getDoneTimerString(*timer))
		}
	} else {
		for _, v := range *a.TimerList {
			if v.Finished {
				if err := a.archiveTimer(v.Id); err != nil {
					fmt.Printf("Error archiving task %d\n", v.Id)
					return 1
				}
				fmt.Println(a.getDoneTimerString(v))
			}
		}
	}
	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
}