gime-flat/main.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"
)

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 {
		parms = os.Args[1:]
	} 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 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]             - 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 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)
	}
}