346 lines
9.2 KiB
Go
346 lines
9.2 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
userConfig "github.com/br0xen/user-config"
|
|
)
|
|
|
|
const (
|
|
AppName = "gime-flat"
|
|
AppVersion = 0.1
|
|
DefDBName = "./gime"
|
|
DefRoundTo = "1m0s"
|
|
)
|
|
|
|
// Gime CLI Timekeeping
|
|
|
|
var validOperations map[string][]string
|
|
var opFuncs map[string]func([]string) int
|
|
var cfg *userConfig.Config
|
|
var roundTo time.Duration
|
|
|
|
var fuzzyFormats []string
|
|
|
|
func main() {
|
|
var ret int
|
|
initialize()
|
|
var parms []string
|
|
|
|
if len(os.Args) > 1 && !strings.HasPrefix(os.Args[1], ":") {
|
|
parms = os.Args[1:]
|
|
} else {
|
|
// If no parameters were passed, just print the status
|
|
parms = append(parms, "status")
|
|
if strings.HasPrefix(os.Args[1], ":") {
|
|
parms = append(parms, os.Args[1:]...)
|
|
}
|
|
}
|
|
|
|
if fn, ok := opFuncs[parms[0]]; ok {
|
|
ret = fn(parms[1:])
|
|
} else {
|
|
fmt.Println("Unknown command")
|
|
ret = 1
|
|
}
|
|
os.Exit(ret)
|
|
}
|
|
|
|
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("Are you sure you want to reset your configuration? (Y/[N])")
|
|
reader := bufio.NewReader(os.Stdin)
|
|
conf, _ := reader.ReadString('\n')
|
|
conf = strings.TrimSpace(conf)
|
|
if conf == "Y" {
|
|
fmt.Println("Resetting Configuration...")
|
|
cfg.Set("dbdir", cfg.GetConfigPath()+string(os.PathSeparator))
|
|
cfg.Set("dbname", DefDBName)
|
|
cfg.Set("roundto", DefRoundTo)
|
|
} else {
|
|
fmt.Println("Done.")
|
|
}
|
|
return 0
|
|
|
|
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"))
|
|
}
|
|
} 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] != os.PathSeparator {
|
|
val = val + string(os.PathSeparator)
|
|
}
|
|
cfg.Set("dbdir", val)
|
|
case "dbname":
|
|
cfg.Set("dbname", pts[1])
|
|
case "dbarchname":
|
|
cfg.Set("dbarchname", pts[1])
|
|
case "roundto":
|
|
// Make sure that we can parse it
|
|
durStr := pts[1]
|
|
_, err := time.ParseDuration(durStr)
|
|
if err != nil {
|
|
fmt.Println("Unable to parse duration:", durStr)
|
|
durStr = DefRoundTo
|
|
}
|
|
cfg.Set("roundto", durStr)
|
|
fmt.Println("Rounding set to", durStr)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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 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["add"] = cmdAddTimer
|
|
validOperations["add"] = []string{
|
|
"add [duration] [+tags] - Add a timer for the given duration",
|
|
" with the given tags",
|
|
}
|
|
|
|
opFuncs["cont"] = cmdContinueTimer
|
|
validOperations["cont"] = []string{
|
|
"cont [time] [+tags] - Continue the last stopped timer",
|
|
" Any tags given will be added",
|
|
}
|
|
|
|
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 uuid - 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",
|
|
" Or other date values, we'll try to parse it.",
|
|
" To list entries by tag, preceed the tags with a +",
|
|
}
|
|
|
|
opFuncs["ls"] = cmdPrintList
|
|
validOperations["ls"] = []string{
|
|
"ls [duration] [+tags] - The same as list",
|
|
}
|
|
|
|
opFuncs["modify"] = cmdModifyTimer
|
|
validOperations["modify"] = []string{
|
|
"modify [+tags] - Modify a timer",
|
|
}
|
|
|
|
opFuncs["mod"] = cmdModifyTimer
|
|
validOperations["mod"] = []string{
|
|
"mod [+tags] - Modify a timer",
|
|
}
|
|
|
|
opFuncs["remove"] = cmdDeleteTimer
|
|
validOperations["remove"] = []string{
|
|
"remove uuid - See 'delete'",
|
|
}
|
|
opFuncs["rm"] = cmdDeleteTimer
|
|
validOperations["rm"] = []string{
|
|
"rm uuid - 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["fuzzyparse"] = cmdDoFuzzyParse
|
|
validOperations["fuzzyparse"] = []string{
|
|
"fuzzyparse - Parse the next argument as a date/time and print",
|
|
" the RFC3339 result. (Basically for testing)",
|
|
}
|
|
|
|
opFuncs["tags"] = cmdManageTag
|
|
validOperations["tags"] = []string{
|
|
"tags - Same as 'tag'",
|
|
}
|
|
|
|
opFuncs["tag"] = cmdManageTag
|
|
validOperations["tag"] = []string{
|
|
"tag [+name [:[non]bill] [+newname]] - Manage tags",
|
|
" If no tag is requested, list all tags",
|
|
" If tag is requested and:",
|
|
" newname is given, rename the tag",
|
|
" :non[[bill]able] - set tag to non-billable",
|
|
" :bill[able] - set tag to billable",
|
|
}
|
|
|
|
// 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 gdb, err = gime.LoadDatabase(cfg.Get("dbdir"), cfg.Get("dbname"), cfg.Get("dbarchname")); err != nil {
|
|
fmt.Println("Error loading the database")
|
|
os.Exit(1)
|
|
}
|
|
*/
|
|
if _, err := time.ParseDuration(cfg.Get("roundto")); err != nil {
|
|
cfg.Set("roundto", DefRoundTo)
|
|
}
|
|
|
|
fuzzyFormats = []string{
|
|
"1504",
|
|
"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",
|
|
"20060102T15:04",
|
|
"20060102T15:04:05",
|
|
"20060102T1504",
|
|
"20060102T150405",
|
|
}
|
|
}
|
|
|
|
func assertError(err error) {
|
|
if err != nil {
|
|
fmt.Println(err.Error())
|
|
os.Exit(1)
|
|
}
|
|
}
|