214 lines
4.5 KiB
Go
214 lines
4.5 KiB
Go
package interactive
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
cli "git.tcp.direct/Mirrors/go-prompt"
|
|
tui "github.com/manifoldco/promptui"
|
|
"github.com/rs/zerolog"
|
|
|
|
"git.tcp.direct/kayos/ziggs/internal/common"
|
|
"git.tcp.direct/kayos/ziggs/internal/config"
|
|
"git.tcp.direct/kayos/ziggs/internal/ziggy"
|
|
)
|
|
|
|
var log *zerolog.Logger
|
|
|
|
func validate(input string) error {
|
|
if len(strings.TrimSpace(input)) < 1 {
|
|
return errors.New("no input detected")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func InteractiveAuth() string {
|
|
passPrompt := tui.Prompt{
|
|
Label: "API Key (AKA user)",
|
|
Validate: validate,
|
|
Mask: '',
|
|
}
|
|
|
|
for {
|
|
key, perr := passPrompt.Run()
|
|
|
|
if perr != nil {
|
|
fmt.Println(tui.IconBad + perr.Error())
|
|
continue
|
|
}
|
|
return key
|
|
}
|
|
}
|
|
|
|
// Interpret is where we will actuall define our commands
|
|
func executor(cmd string) {
|
|
cmd = strings.TrimSpace(cmd)
|
|
var args = strings.Fields(cmd)
|
|
switch args[0] {
|
|
case "quit", "exit":
|
|
os.Exit(0)
|
|
case "use":
|
|
if len(args) < 2 {
|
|
println("use: use <bridge>")
|
|
return
|
|
}
|
|
if br, ok := ziggy.Lucifer.Bridges[args[1]]; !ok {
|
|
println("invalid bridge: " + args[1])
|
|
} else {
|
|
selectedBridge = args[1]
|
|
log.Info().Str("host", br.Host).Int("lights", len(br.HueLights)).Msg("switched to bridge: " + selectedBridge)
|
|
}
|
|
case "debug":
|
|
levelsdebug := map[string]zerolog.Level{"info": zerolog.InfoLevel, "debug": zerolog.DebugLevel, "trace": zerolog.TraceLevel}
|
|
debuglevels := map[zerolog.Level]string{zerolog.InfoLevel: "info", zerolog.DebugLevel: "debug", zerolog.TraceLevel: "trace"}
|
|
if len(args) < 2 {
|
|
println("current debug level: " + debuglevels[log.GetLevel()])
|
|
}
|
|
if newlevel, ok := levelsdebug[args[1]]; ok {
|
|
zerolog.SetGlobalLevel(newlevel)
|
|
}
|
|
case "help":
|
|
if len(args) < 2 {
|
|
getHelp("meta")
|
|
return
|
|
}
|
|
getHelp(args[len(args)-1])
|
|
case "clear":
|
|
print("\033[H\033[2J")
|
|
default:
|
|
bcmd, ok := bridgeCMD[args[0]]
|
|
if !ok {
|
|
return
|
|
}
|
|
br, ok := ziggy.Lucifer.Bridges[selectedBridge]
|
|
if selectedBridge == "" || !ok {
|
|
prompt := tui.Select{
|
|
Label: "Send to all known bridges?",
|
|
Items: []string{"yes", "no"},
|
|
Pointer: common.ZiggsPointer,
|
|
}
|
|
_, ch, _ := prompt.Run()
|
|
if ch != "yes" {
|
|
return
|
|
}
|
|
for _, br := range ziggy.Lucifer.Bridges {
|
|
go bcmd(br, args[1:])
|
|
}
|
|
} else {
|
|
err := bcmd(br, args[1:])
|
|
if err != nil {
|
|
log.Error().Err(err).Msg("error executing command")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func getHelp(target string) {
|
|
fmt.Printf("pRaNkeD! (help not available just yet.)\n")
|
|
/*
|
|
var lines []string
|
|
|
|
lines = append(lines, "help: "+target)
|
|
|
|
switch target {
|
|
|
|
case "meta":
|
|
var list string
|
|
for _, cmd := range cmds {
|
|
list = list + cmd + ", "
|
|
}
|
|
|
|
fmt.Println("Enabled commands: ")
|
|
list = strings.TrimSuffix(list, ", ")
|
|
fmt.Println(list)
|
|
fmt.Println()
|
|
|
|
default:
|
|
log.Error().Msg("Help entry not found!")
|
|
fmt.Println()
|
|
}
|
|
*/
|
|
}
|
|
|
|
func cmdScan(br *ziggy.Bridge, args []string) error {
|
|
r, err := br.FindLights()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for resp := range r.Success {
|
|
log.Info().Msg(resp)
|
|
}
|
|
var count = 0
|
|
timer := time.NewTimer(5 * time.Second)
|
|
var newLights []string
|
|
loop:
|
|
for {
|
|
select {
|
|
case <-timer.C:
|
|
break loop
|
|
default:
|
|
newl, _ := br.GetNewLights()
|
|
if len(newl.Lights) <= count {
|
|
time.Sleep(250 * time.Millisecond)
|
|
print(".")
|
|
continue
|
|
}
|
|
count = len(newl.Lights)
|
|
timer.Reset(5 * time.Second)
|
|
newLights = append(newLights, newl.Lights...)
|
|
}
|
|
}
|
|
for _, nl := range newLights {
|
|
log.Info().Str("caller", nl).Msg("discovered light")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var selectedBridge = ""
|
|
|
|
const bulb = ``
|
|
|
|
func getHist() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func StartCLI() {
|
|
log = config.GetLogger()
|
|
processBridges(ziggy.Lucifer.Bridges)
|
|
for _, br := range ziggy.Lucifer.Bridges {
|
|
grpmap, err := getGroupMap(br)
|
|
if err != nil {
|
|
log.Warn().Err(err).Msg("error getting group map")
|
|
} else {
|
|
processGroups(br, grpmap)
|
|
}
|
|
}
|
|
|
|
p := cli.New(
|
|
executor,
|
|
completer,
|
|
// cli.OptionPrefixBackgroundColor(cli.Black),
|
|
cli.OptionPrefixTextColor(cli.Yellow),
|
|
cli.OptionHistory(getHist()),
|
|
cli.OptionSuggestionBGColor(cli.Black),
|
|
cli.OptionSuggestionTextColor(cli.White),
|
|
cli.OptionSelectedSuggestionBGColor(cli.Black),
|
|
cli.OptionSelectedSuggestionTextColor(cli.Green),
|
|
cli.OptionLivePrefix(
|
|
func() (prefix string, useLivePrefix bool) {
|
|
sel := "~"
|
|
if len(ziggy.Lucifer.Bridges) > 1 && selectedBridge != "" {
|
|
sel = selectedBridge
|
|
}
|
|
return fmt.Sprintf("ziggs[%s] %s ", sel, bulb), true
|
|
}),
|
|
cli.OptionTitle("ziggs"),
|
|
cli.OptionCompletionOnDown(),
|
|
)
|
|
|
|
p.Run()
|
|
}
|