mirror of
https://github.com/MickMake/GoSungrow.git
synced 2025-12-11 21:21:05 +01:00
355 lines
11 KiB
Go
355 lines
11 KiB
Go
package cmd
|
|
|
|
import (
|
|
"GoSungro/Only"
|
|
"GoSungro/iSolarCloud"
|
|
"GoSungro/mmGit"
|
|
"fmt"
|
|
"github.com/spf13/cobra"
|
|
"github.com/spf13/pflag"
|
|
"github.com/spf13/viper"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
var SunGro *iSolarCloud.SunGro
|
|
var Git *mmGit.Git
|
|
var Cmd CommandArgs
|
|
var rootViper *viper.Viper
|
|
|
|
var rootCmd = &cobra.Command{
|
|
Use: DefaultBinaryName,
|
|
Short: fmt.Sprintf("%s - Manage an SunGro instance", DefaultBinaryName),
|
|
Long: fmt.Sprintf("%s - Manage an SunGro instance", DefaultBinaryName),
|
|
Run: gbRootFunc,
|
|
TraverseChildren: true,
|
|
PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
|
|
// You can bind cobra and viper in a few locations, but PersistencePreRunE on the root command works well
|
|
return initConfig(cmd)
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
for range Only.Once {
|
|
rootViper = viper.New()
|
|
|
|
Cmd.ConfigDir, Cmd.Error = os.UserHomeDir()
|
|
if Cmd.Error != nil {
|
|
break
|
|
}
|
|
Cmd.ConfigDir = filepath.Join(Cmd.ConfigDir, "."+DefaultBinaryName)
|
|
|
|
_, Cmd.Error = os.Stat(Cmd.ConfigDir)
|
|
if os.IsExist(Cmd.Error) {
|
|
break
|
|
}
|
|
|
|
Cmd.Error = os.MkdirAll(Cmd.ConfigDir, 0700)
|
|
if Cmd.Error != nil {
|
|
break
|
|
}
|
|
|
|
Cmd.ConfigFile = filepath.Join(Cmd.ConfigDir, defaultConfigFile)
|
|
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.ApiUsername, flagApiUsername, "u", "", fmt.Sprintf("SunGro: api username."))
|
|
rootViper.SetDefault(flagApiUsername, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.ApiPassword, flagApiPassword, "p", "", fmt.Sprintf("SunGro: api password."))
|
|
rootViper.SetDefault(flagApiPassword, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.ApiAppKey, flagApiAppKey, "", "", fmt.Sprintf("SunGro: api application key."))
|
|
rootViper.SetDefault(flagApiAppKey, "")
|
|
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.ApiUrl, flagApiUrl, "", defaultHost, fmt.Sprintf("SunGro: Provider API URL."))
|
|
rootViper.SetDefault(flagApiUrl, "")
|
|
rootCmd.PersistentFlags().DurationVarP(&Cmd.ApiTimeout, flagApiTimeout, "", defaultTimeout, fmt.Sprintf("SunGro: API timeout."))
|
|
rootViper.SetDefault(flagApiTimeout, "")
|
|
rootCmd.PersistentFlags().StringVar(&Cmd.ApiTokenExpiry, flagApiTokenExpiry, "", "SunGro: token expiry.")
|
|
rootViper.SetDefault(flagApiTokenExpiry, "")
|
|
_ = rootCmd.PersistentFlags().MarkHidden(flagApiTokenExpiry)
|
|
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GoogleSheet, flagGoogleSheet, "", "", fmt.Sprintf("Google: Sheet URL for updates."))
|
|
rootViper.SetDefault(flagGoogleSheet, "")
|
|
rootCmd.PersistentFlags().BoolVarP(&Cmd.GoogleSheetUpdate, flagGoogleSheetUpdate, "", false, fmt.Sprintf("Update Google sheets."))
|
|
rootViper.SetDefault(flagGoogleSheetUpdate, false)
|
|
_ = rootCmd.PersistentFlags().MarkHidden(flagGoogleSheetUpdate)
|
|
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GitRepo, flagGitRepo, "", "", fmt.Sprintf("Git: Repo url for updates."))
|
|
rootViper.SetDefault(flagGitRepo, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GitRepoDir, flagGitRepoDir, "", "", fmt.Sprintf("Git: Local repo directory."))
|
|
rootViper.SetDefault(flagGitRepoDir, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GitUsername, flagGitUsername, "", "", fmt.Sprintf("Git: Repo username."))
|
|
rootViper.SetDefault(flagGitUsername, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GitPassword, flagGitPassword, "", "", fmt.Sprintf("Git: Repo password."))
|
|
rootViper.SetDefault(flagGitPassword, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GitKeyFile, flagGitKeyFile, "", "", fmt.Sprintf("Git: Repo SSH keyfile."))
|
|
rootViper.SetDefault(flagGitKeyFile, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GitToken, flagGitToken, "", "", fmt.Sprintf("Git: Repo token string."))
|
|
rootViper.SetDefault(flagGitToken, "")
|
|
rootCmd.PersistentFlags().StringVarP(&Cmd.GitDiffCmd, flagGitDiffCmd, "", "tkdiff", fmt.Sprintf("Git: Command for diffs."))
|
|
rootViper.SetDefault(flagGitDiffCmd, "tkdiff")
|
|
|
|
rootCmd.PersistentFlags().StringVar(&Cmd.ConfigFile, flagConfigFile, Cmd.ConfigFile, fmt.Sprintf("%s: config file.", DefaultBinaryName))
|
|
//_ = rootCmd.PersistentFlags().MarkHidden(flagConfigFile)
|
|
rootCmd.PersistentFlags().BoolVarP(&Cmd.Debug, flagDebug, "", false, fmt.Sprintf("%s: Debug mode.", DefaultBinaryName))
|
|
rootViper.SetDefault(flagDebug, false)
|
|
rootCmd.PersistentFlags().BoolVarP(&Cmd.Quiet, flagQuiet, "q", false, fmt.Sprintf("%s: Silence all messages.", DefaultBinaryName))
|
|
rootViper.SetDefault(flagQuiet, false)
|
|
|
|
//cobra.OnInitialize(initConfig)
|
|
cobra.EnableCommandSorting = false
|
|
rootCmd.PersistentFlags().SortFlags = false
|
|
rootCmd.Flags().SortFlags = false
|
|
}
|
|
}
|
|
|
|
func InitCommands() error {
|
|
var err error
|
|
|
|
for range Only.Once {
|
|
rootCmd.AddCommand(cmdConfig, cmdSync, cmdApi, cmdGit, cmdGoogle, cmdCron, cmdVersion, cmdHelpFlags)
|
|
cmdConfig.AddCommand(cmdConfigWrite, cmdConfigRead)
|
|
cmdGit.AddCommand(cmdSave, cmdGitLs, cmdGitDiff, cmdGitClone, cmdGitPull, cmdGitPush, cmdGitCommit, cmdGitAdd)
|
|
cmdGoogle.AddCommand(cmdGoogleUpdate)
|
|
cmdCron.AddCommand(cmdCronRun, cmdCronAdd, cmdCronRemove, cmdCronList)
|
|
|
|
cmdApi.AddCommand(cmdApiList, cmdApiPut, cmdApiGet)
|
|
//cmdApiList.AddCommand(
|
|
// cmdListCharts,
|
|
//)
|
|
//cmdApiGet.AddCommand(
|
|
// cmdCountCharts,
|
|
//)
|
|
//cmdApiPut.AddCommand(
|
|
// cmdReadCharts,
|
|
//)
|
|
|
|
//foo := rootCmd.HelpTemplate()
|
|
//foo := rootCmd.UsageTemplate()
|
|
//foo := rootCmd.VersionTemplate()
|
|
//fmt.Println(foo)
|
|
|
|
rootCmd.SetHelpTemplate(DefaultHelpTemplate)
|
|
rootCmd.SetUsageTemplate(DefaultUsageTemplate)
|
|
rootCmd.SetVersionTemplate(DefaultVersionTemplate)
|
|
|
|
foo := rootCmd.Commands()
|
|
foo[0].CommandPath()
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// initConfig reads in config file and ENV variables if set.
|
|
func initConfig(cmd *cobra.Command) error {
|
|
var err error
|
|
|
|
for range Only.Once {
|
|
rootViper = viper.New()
|
|
rootViper.AddConfigPath(Cmd.ConfigDir)
|
|
rootViper.SetConfigFile(Cmd.ConfigFile)
|
|
//rootViper.SetConfigName("config")
|
|
|
|
// If a config file is found, read it in.
|
|
err = openConfig()
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
rootViper.SetEnvPrefix(EnvPrefix)
|
|
rootViper.AutomaticEnv() // read in environment variables that match
|
|
err = bindFlags(cmd, rootViper)
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func openConfig() error {
|
|
var err error
|
|
|
|
for range Only.Once {
|
|
err = rootViper.ReadInConfig()
|
|
if _, ok := err.(viper.UnsupportedConfigError); ok {
|
|
break
|
|
}
|
|
|
|
if _, ok := err.(viper.ConfigParseError); ok {
|
|
break
|
|
}
|
|
|
|
if _, ok := err.(viper.ConfigMarshalError); ok {
|
|
break
|
|
}
|
|
|
|
if os.IsNotExist(err) {
|
|
rootViper.SetDefault(flagDebug, Cmd.Debug)
|
|
rootViper.SetDefault(flagQuiet, Cmd.Quiet)
|
|
rootViper.SetDefault(flagApiTokenExpiry, Cmd.ApiTokenExpiry)
|
|
|
|
rootViper.SetDefault(flagApiUrl, Cmd.ApiUrl)
|
|
rootViper.SetDefault(flagApiTimeout, Cmd.ApiTimeout)
|
|
rootViper.SetDefault(flagApiUsername, defaultUsername)
|
|
rootViper.SetDefault(flagApiPassword, defaultPassword)
|
|
rootViper.SetDefault(flagApiAppKey, Cmd.ApiAppKey)
|
|
|
|
rootViper.SetDefault(flagGoogleSheet, Cmd.GoogleSheet)
|
|
rootViper.SetDefault(flagGoogleSheetUpdate, Cmd.GoogleSheetUpdate)
|
|
|
|
rootViper.SetDefault(flagGitRepo, Cmd.GitRepo)
|
|
rootViper.SetDefault(flagGitRepoDir, Cmd.GitRepoDir)
|
|
rootViper.SetDefault(flagGitUsername, Cmd.GitUsername)
|
|
rootViper.SetDefault(flagGitPassword, Cmd.GitPassword)
|
|
rootViper.SetDefault(flagGitKeyFile, Cmd.GitKeyFile)
|
|
rootViper.SetDefault(flagGitToken, Cmd.GitToken)
|
|
rootViper.SetDefault(flagGitDiffCmd, Cmd.GitDiffCmd)
|
|
|
|
err = rootViper.WriteConfig()
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
err = rootViper.ReadInConfig()
|
|
break
|
|
}
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
err = rootViper.MergeInConfig()
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
//err = viper.Unmarshal(Cmd)
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func writeConfig() error {
|
|
var err error
|
|
|
|
for range Only.Once {
|
|
err = rootViper.MergeInConfig()
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
rootViper.Set(flagDebug, Cmd.Debug)
|
|
rootViper.Set(flagQuiet, Cmd.Quiet)
|
|
rootViper.Set(flagApiTokenExpiry, Cmd.ApiTokenExpiry)
|
|
|
|
rootViper.Set(flagApiUrl, Cmd.ApiUrl)
|
|
rootViper.Set(flagApiTimeout, Cmd.ApiTimeout)
|
|
rootViper.Set(flagApiUsername, Cmd.ApiUsername)
|
|
rootViper.Set(flagApiPassword, Cmd.ApiPassword)
|
|
rootViper.Set(flagApiAppKey, Cmd.ApiAppKey)
|
|
|
|
rootViper.Set(flagGoogleSheet, Cmd.GoogleSheet)
|
|
rootViper.Set(flagGoogleSheetUpdate, Cmd.GoogleSheetUpdate)
|
|
|
|
rootViper.Set(flagGitRepo, Cmd.GitRepo)
|
|
rootViper.Set(flagGitRepoDir, Cmd.GitRepoDir)
|
|
rootViper.Set(flagGitUsername, Cmd.GitUsername)
|
|
rootViper.Set(flagGitPassword, Cmd.GitPassword)
|
|
rootViper.Set(flagGitKeyFile, Cmd.GitKeyFile)
|
|
rootViper.Set(flagGitToken, Cmd.GitToken)
|
|
rootViper.Set(flagGitDiffCmd, Cmd.GitDiffCmd)
|
|
|
|
err = rootViper.WriteConfig()
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func readConfig() error {
|
|
var err error
|
|
|
|
for range Only.Once {
|
|
err = rootViper.ReadInConfig()
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
_, _ = fmt.Fprintln(os.Stderr, "Config file settings:")
|
|
|
|
_, _ = fmt.Fprintf(os.Stderr, "Api Url: %v\n", rootViper.Get(flagApiUrl))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Api AppKey: %v\n", rootViper.Get(flagApiAppKey))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Api Username: %v\n", rootViper.Get(flagApiUsername))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Api Password: %v\n", rootViper.Get(flagApiPassword))
|
|
_, _ = fmt.Fprintln(os.Stderr)
|
|
|
|
_, _ = fmt.Fprintf(os.Stderr, "Git Repo URL: %v\n", rootViper.Get(flagGitRepo))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Git Repo Dir: %v\n", rootViper.Get(flagGitRepoDir))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Git Repo User: %v\n", rootViper.Get(flagGitUsername))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Git Repo ApiPassword: %v\n", rootViper.Get(flagGitPassword))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Git SSH keyfile: %v\n", rootViper.Get(flagGitKeyFile))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Git Token: %v\n", rootViper.Get(flagGitToken))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Git Diff Command: %v\n", rootViper.Get(flagGitDiffCmd))
|
|
_, _ = fmt.Fprintln(os.Stderr)
|
|
|
|
_, _ = fmt.Fprintf(os.Stderr, "Debug: %v\n", rootViper.Get(flagDebug))
|
|
_, _ = fmt.Fprintf(os.Stderr, "Quiet: %v\n", rootViper.Get(flagQuiet))
|
|
_, _ = fmt.Fprintf(os.Stderr, "ApiTimeout: %v\n", rootViper.Get(flagApiTimeout))
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func bindFlags(cmd *cobra.Command, v *viper.Viper) error {
|
|
var err error
|
|
|
|
cmd.Flags().VisitAll(func(f *pflag.Flag) {
|
|
// Environment variables can't have dashes in them, so bind them to their equivalent
|
|
// keys with underscores, e.g. --favorite-color to STING_FAVORITE_COLOR
|
|
if strings.Contains(f.Name, "-") {
|
|
envVarSuffix := strings.ToUpper(strings.ReplaceAll(f.Name, "-", "_"))
|
|
err = v.BindEnv(f.Name, fmt.Sprintf("%s_%s", EnvPrefix, envVarSuffix))
|
|
}
|
|
|
|
// Apply the viper config value to the flag when the flag is not set and viper has a value
|
|
if !f.Changed && v.IsSet(f.Name) {
|
|
val := v.Get(f.Name)
|
|
err = cmd.Flags().Set(f.Name, fmt.Sprintf("%v", val))
|
|
}
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
func gbRootFunc(cmd *cobra.Command, args []string) {
|
|
for range Only.Once {
|
|
if len(args) == 0 {
|
|
_ = cmd.Help()
|
|
break
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Execute adds all child commands to the root command and sets flags appropriately.
|
|
// This is called by main.main(). It only needs to happen once to the rootCmd.
|
|
func Execute() error {
|
|
for range Only.Once {
|
|
Cmd.Error = InitCommands()
|
|
if Cmd.Error != nil {
|
|
break
|
|
}
|
|
|
|
err := rootCmd.Execute()
|
|
if err != nil {
|
|
break
|
|
}
|
|
if Cmd.Error != nil {
|
|
break
|
|
}
|
|
}
|
|
|
|
return Cmd.Error
|
|
}
|