435 lines
11 KiB
Go
435 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.bullercodeworks.com/brian/gime"
|
|
userConfig "github.com/br0xen/user-config"
|
|
)
|
|
|
|
const (
|
|
AppName = "gime"
|
|
AppVersion = 1
|
|
DefDBName = "gime.db"
|
|
DefArchDBName = "gimearch.db"
|
|
)
|
|
|
|
var validOperations map[string][]string
|
|
var opFuncs map[string]func([]string) int
|
|
var timeEntries *gime.TimeEntryCollection
|
|
var gdb *gime.GimeDB
|
|
var cfg *userConfig.Config
|
|
|
|
var fuzzyFormats []string
|
|
|
|
func main() {
|
|
var ret int
|
|
initialize()
|
|
var parms []string
|
|
|
|
if len(os.Args) > 1 {
|
|
parms = os.Args[1:]
|
|
parms[0] = matchParameter(parms[0])
|
|
} else {
|
|
// If no parameters were passed, just print the status
|
|
parms = append(parms, "status")
|
|
}
|
|
|
|
if fn, ok := opFuncs[parms[0]]; ok {
|
|
ret = fn(parms[1:])
|
|
} else {
|
|
fmt.Println("Unknown command")
|
|
ret = 1
|
|
}
|
|
os.Exit(ret)
|
|
}
|
|
|
|
func loadActiveTimeEntries() {
|
|
timeEntries = gdb.LoadTimeEntryCollection(gime.TypeCurrent)
|
|
}
|
|
|
|
func loadActiveAndRecentTimeEntries() {
|
|
timeEntries = gdb.LoadTimeEntryCollection(gime.TypeNoArchive)
|
|
}
|
|
|
|
func getMostRecentTimeEntry() (*gime.TimeEntry, error) {
|
|
return gdb.GetLatestTimeEntry()
|
|
}
|
|
|
|
func cmdDoArchive(args []string) int {
|
|
fmt.Println("Not implemented yet.")
|
|
return 1
|
|
}
|
|
|
|
func cmdDoConfig(args []string) int {
|
|
if len(args) == 0 {
|
|
fmt.Println("Invalid configuration options passed")
|
|
return 1
|
|
}
|
|
|
|
for _, opt := range args {
|
|
if !strings.Contains(opt, "=") {
|
|
// Single word triggers
|
|
switch opt {
|
|
case "reset":
|
|
fmt.Println("Resetting Configuration...")
|
|
cfg.Set("dbdir", cfg.GetConfigPath()+"/")
|
|
cfg.Set("dbname", DefDBName)
|
|
cfg.Set("dbarchname", DefArchDBName)
|
|
case "list":
|
|
fmt.Println("Current " + AppName + " config")
|
|
for _, v := range cfg.GetKeyList() {
|
|
fmt.Println(" " + v + ": " + cfg.Get(v))
|
|
}
|
|
case "dbpath":
|
|
fmt.Println(cfg.Get("dbdir") + cfg.Get("dbname"))
|
|
}
|
|
} else {
|
|
// Key=Value options
|
|
pts := strings.Split(opt, "=")
|
|
if len(pts) == 2 {
|
|
switch pts[0] {
|
|
case "dbdir":
|
|
val := pts[1]
|
|
if val[len(val)-1] != '/' {
|
|
val = val + "/"
|
|
}
|
|
cfg.Set("dbdir", val)
|
|
case "dbname":
|
|
cfg.Set("dbname", pts[1])
|
|
case "dbarchname":
|
|
cfg.Set("dbarchname", pts[1])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func cmdPrintDetail(args []string) int {
|
|
fmt.Println("Not implemented yet.")
|
|
return 1
|
|
}
|
|
|
|
func cmdPrintHelp(args []string) int {
|
|
if len(args) == 0 {
|
|
fmt.Println("gime - A simple timekeeping application\n")
|
|
fmt.Println("Usage: gime [@timerID] [operation] [tags...]")
|
|
for _, v := range validOperations {
|
|
for vi := range v {
|
|
fmt.Println(" ", v[vi])
|
|
}
|
|
fmt.Println("")
|
|
}
|
|
} else {
|
|
switch args[0] {
|
|
case "formats":
|
|
fmt.Println("Supported date/time formats:")
|
|
for i := range fuzzyFormats {
|
|
fmt.Println(" ", fuzzyFormats[i])
|
|
}
|
|
}
|
|
fmt.Println("")
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func cmdPrintList(args []string) int {
|
|
loadActiveAndRecentTimeEntries()
|
|
|
|
useDefaultFilter := true
|
|
|
|
var beg, end time.Time
|
|
searchTags := []string{}
|
|
|
|
for _, opt := range args {
|
|
var tmpBeg, tmpEnd time.Time
|
|
|
|
// Do our best to figure out what timers the user wants to list
|
|
var err error
|
|
if strings.Contains(opt, "-") {
|
|
useDefaultFilter = false
|
|
pts := strings.Split(opt, "-")
|
|
if len(pts[0]) > 0 {
|
|
// This should be the starting date
|
|
tmpBeg, err = parseFuzzyTime(pts[0])
|
|
if err != nil {
|
|
// We couldn't parse it as a time,
|
|
// Probably this is just a tag
|
|
searchTags = append(searchTags, opt)
|
|
continue
|
|
}
|
|
}
|
|
if len(pts[1]) > 0 {
|
|
// This should be the ending date
|
|
tmpEnd, err = parseFuzzyTime(pts[1])
|
|
if err != nil {
|
|
searchTags = append(searchTags, opt)
|
|
continue
|
|
}
|
|
}
|
|
} else {
|
|
// Tag filters
|
|
searchTags = append(searchTags, opt)
|
|
}
|
|
if !tmpBeg.IsZero() || !tmpEnd.IsZero() {
|
|
beg, end = tmpBeg, tmpEnd
|
|
}
|
|
}
|
|
if end.IsZero() {
|
|
end = time.Now()
|
|
}
|
|
|
|
// By default, list all entries ending today or still running
|
|
defaultFilter := func(t *gime.TimeEntry) bool {
|
|
return t.EndsToday() || t.IsRunning()
|
|
}
|
|
|
|
timeSpanFilter := func(t *gime.TimeEntry) bool {
|
|
return t.GetStart().After(beg) && t.GetEnd().Before(end)
|
|
}
|
|
tagFilter := func(t *gime.TimeEntry) bool {
|
|
for i := range searchTags {
|
|
if !t.HasTag(searchTags[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
compoundFilter := func(t *gime.TimeEntry) bool {
|
|
// If we didn't get any other filter specifications, just use the default
|
|
if useDefaultFilter {
|
|
return defaultFilter(t)
|
|
}
|
|
// Otherwise we want to filter timespan and tags
|
|
return timeSpanFilter(t) && tagFilter(t)
|
|
}
|
|
|
|
fmt.Println(time.Now().Format("2006/01/02"))
|
|
str := TimerCollectionToString(filterTimerCollection(timeEntries, compoundFilter))
|
|
str = " " + strings.Replace(str, "\n", "\n ", -1)
|
|
fmt.Println(str)
|
|
return 0
|
|
}
|
|
|
|
func cmdPrintStatus(args []string) int {
|
|
loadActiveTimeEntries()
|
|
curr := time.Now()
|
|
fmt.Println("Current Time:", curr.Format(time.Stamp))
|
|
if timeEntries.Length() == 0 {
|
|
fmt.Println("No timer running")
|
|
} else {
|
|
fmt.Print("Active Timers (", timeEntries.Length(), ")\n")
|
|
// Find the longest start time & longest duration
|
|
short := true
|
|
for i := 0; i < timeEntries.Length(); i++ {
|
|
v := timeEntries.Get(i)
|
|
if v.GetStart().Day() != curr.Day() {
|
|
short = false
|
|
break
|
|
}
|
|
}
|
|
|
|
for i := 0; i < timeEntries.Length(); i++ {
|
|
v := timeEntries.Get(i)
|
|
if short {
|
|
fmt.Printf(" @%d %s\n", i, TimerDetailToString(v))
|
|
} else {
|
|
fmt.Printf(" @%d %s\n", i, TimerDetailToLongString(v))
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func cmdDoFuzzyParse(args []string) int {
|
|
if len(args) == 0 {
|
|
return 1
|
|
}
|
|
var t time.Time
|
|
var err error
|
|
if t, err = parseFuzzyTime(args[0]); err != nil {
|
|
fmt.Println(err.Error())
|
|
return 1
|
|
}
|
|
fmt.Println(t.Format(time.RFC3339))
|
|
return 0
|
|
}
|
|
|
|
func initialize() {
|
|
var err error
|
|
validOperations = make(map[string][]string)
|
|
opFuncs = make(map[string]func([]string) int)
|
|
|
|
opFuncs["cont"] = cmdContinueTimer
|
|
validOperations["cont"] = []string{
|
|
"cont [time] - Continue the last stopped timer",
|
|
}
|
|
|
|
opFuncs["config"] = cmdDoConfig
|
|
validOperations["config"] = []string{
|
|
"config [command] - Perform configuration",
|
|
" list - List current configuration",
|
|
" reset - Reset current configuration",
|
|
" Configuration Options:",
|
|
" dbdir=[database directory]",
|
|
" dbname=[database filename]",
|
|
" dbarchname=[archive database filename]",
|
|
}
|
|
|
|
opFuncs["detail"] = cmdPrintDetail
|
|
validOperations["detail"] = []string{
|
|
"detail @id - Print details about a timer",
|
|
}
|
|
|
|
opFuncs["delete"] = cmdDeleteTimer
|
|
validOperations["delete"] = []string{
|
|
"delete @id - Delete a timer",
|
|
}
|
|
|
|
opFuncs["end"] = cmdStopTimer
|
|
validOperations["end"] = []string{
|
|
"end - The same as stop",
|
|
}
|
|
|
|
opFuncs["help"] = cmdPrintHelp
|
|
validOperations["help"] = []string{
|
|
"help - Print this",
|
|
}
|
|
|
|
opFuncs["list"] = cmdPrintList
|
|
validOperations["list"] = []string{
|
|
"list [duration] [+tags] - List time entries",
|
|
" valid values of [duration] include:",
|
|
" day - List all entries for the current day",
|
|
" week - List all entries for the current week",
|
|
" month - List all entries for the current month",
|
|
" year - List all entries for the current year",
|
|
" To list entries by tag, preceed the tags with a +",
|
|
}
|
|
|
|
opFuncs["ls"] = cmdPrintList
|
|
validOperations["ls"] = []string{
|
|
"ls [duration] [+tags] - The same as list",
|
|
}
|
|
|
|
opFuncs["remove"] = cmdDeleteTimer
|
|
validOperations["remove"] = []string{
|
|
"remove @id - See 'delete'",
|
|
}
|
|
|
|
opFuncs["status"] = cmdPrintStatus
|
|
validOperations["status"] = []string{
|
|
"status - Print the status of all active timers",
|
|
}
|
|
|
|
opFuncs["start"] = cmdStartTimer
|
|
validOperations["start"] = []string{
|
|
"start [time] [tags ...] - Start a timer with the given tags (space separated)",
|
|
" If the first sub-argument given looks like a time,",
|
|
" the timer will be started then (past or future).",
|
|
" If a timer is already running it'll be stopped",
|
|
}
|
|
|
|
opFuncs["stop"] = cmdStopTimer
|
|
validOperations["stop"] = []string{
|
|
"stop [time] - Stops the current timer",
|
|
" If the first sub-argument given looks like a time,",
|
|
" the timer will be stopped then (past or future).",
|
|
}
|
|
|
|
opFuncs["switch"] = cmdSwitchTimer
|
|
validOperations["switch"] = []string{
|
|
"switch [tags ...] - Stop all currently running timers and start a new",
|
|
" one with the given tags",
|
|
}
|
|
|
|
opFuncs["archive"] = cmdDoArchive
|
|
validOperations["archive"] = []string{
|
|
"archive - Archive all entries older than the archive date",
|
|
}
|
|
|
|
opFuncs["fuzzyparse"] = cmdDoFuzzyParse
|
|
validOperations["fuzzyparse"] = []string{
|
|
"fuzzyparse - Parse the next argument as a date/time and print",
|
|
" the RFC3339 result. (Basically for testing)",
|
|
}
|
|
|
|
// Load the Config
|
|
cfg, err = userConfig.NewConfig(AppName)
|
|
if err != nil {
|
|
fmt.Println(err.Error())
|
|
fmt.Println("Creating new config")
|
|
cfg.Save()
|
|
}
|
|
// If dbdir isn't set, set it to the config directory
|
|
if cfg.Get("dbdir") == "" {
|
|
cfg.Set("dbdir", cfg.GetConfigPath()+"/")
|
|
}
|
|
// If dbname isn't set, set it to the default database filename
|
|
if cfg.Get("dbname") == "" {
|
|
cfg.Set("dbname", DefDBName)
|
|
}
|
|
// If dbarchivename isn't set, set it to the default archive database filename
|
|
if cfg.Get("dbarchname") == "" {
|
|
cfg.Set("dbarchname", DefArchDBName)
|
|
}
|
|
if gdb, err = gime.LoadDatabase(cfg.Get("dbdir"), cfg.Get("dbname"), cfg.Get("dbarchname")); err != nil {
|
|
fmt.Println("Error loading the database")
|
|
os.Exit(1)
|
|
}
|
|
|
|
fuzzyFormats = []string{
|
|
"15:04", // Kitchen, 24hr
|
|
time.Kitchen,
|
|
time.RFC3339,
|
|
"2006-01-02T15:04:05", // RFC3339 without timezone
|
|
"2006-01-02T15:04", // RFC3339 without seconds or timezone
|
|
time.Stamp,
|
|
"02 Jan 06 15:04:05", // RFC822 with second
|
|
time.RFC822,
|
|
"01/02/2006 15:04", // U.S. Format
|
|
"01/02/2006 15:04:05", // U.S. Format with seconds
|
|
"01/02/06 15:04", // U.S. Format, short year
|
|
"01/02/06 15:04:05", // U.S. Format, short year, with seconds
|
|
"2006-01-02",
|
|
"2006-01-02 15:04",
|
|
"2006-01-02 15:04:05",
|
|
"20060102",
|
|
"20060102 15:04",
|
|
"20060102 15:04:05",
|
|
"20060102 1504",
|
|
"20060102 150405",
|
|
}
|
|
}
|
|
|
|
func matchParameter(in string) string {
|
|
var chkParms []string
|
|
for k := range validOperations {
|
|
chkParms = append(chkParms, k)
|
|
}
|
|
var nextParms []string
|
|
for i := range in {
|
|
for _, p := range chkParms {
|
|
if p[i] == in[i] {
|
|
nextParms = append(nextParms, p)
|
|
}
|
|
}
|
|
// If we get here and there is only one parameter left, return it
|
|
chkParms = nextParms
|
|
if len(nextParms) == 1 {
|
|
break
|
|
}
|
|
// Otherwise, loop
|
|
nextParms = []string{}
|
|
}
|
|
if len(chkParms) == 0 {
|
|
return ""
|
|
}
|
|
return chkParms[0]
|
|
}
|