Support for multiple template and output files

Author: dkrizic

config/config.go

@@ -9,33 +9,40 @@ import (
 )
 
 const (
-	keyAction       = "ACTION"
-	keyEnterprise   = "ENTERPRISE"
-	keyGithubToken  = "GITHUB_TOKEN"
-	keyTemplateFile = "TEMPLATE_FILE"
-	keyVerbose      = "VERBOSE"
-	keyOutputFile   = "OUTPUT_FILE"
-	keyOwnDomains   = "OWN_DOMAINS"
+	keyAction                   = "action"
+	kkeyActionEnvironment       = "ACTION"
+	keyEnterprise               = "enterprise"
+	keyEnterpriseEnvironment    = "ENTERPRISE"
+	keyGithubToken              = "githubToken"
+	keyGithubTokenEnvironment   = "GITHUB_TOKEN"
+	keyTemplateFiles            = "template-files"
+	keyTemplateFilesEnvironment = "TEMPLATE_FILES"
+	keyOutputFiles              = "output-files"
+	keyOutputFilesEnvironment   = "OUTPUT_FILES"
+	keyVerbose                  = "verbose"
+	keyVerboseEnvironment       = "VERBOSE"
+	keyOwnDomains               = "own-domains"
+	keyOwnDomainsEnvironment    = "OWN_DOMAINS"
 )
 
 type Config struct {
-	Action       string
-	Enterprise   string
-	GithubToken  string
-	TemplateFile string
-	OutputFile   string
-	OwnDomains   string
+	Action        string
+	Enterprise    string
+	GithubToken   string
+	TemplateFiles string
+	OutputFiles   string
+	OwnDomains    string
 }
 
 func New() (*Config, error) {
 	c := Config{}
-	flag.StringVar(&c.Action, keyAction, lookupEnvOrString("ACTION", ""), "The action to perform.")
-	flag.StringVar(&c.Enterprise, keyEnterprise, lookupEnvOrString("ENTERPRISE", ""), "The GitHub Enterprise to query for repositories.")
-	flag.StringVar(&c.GithubToken, keyGithubToken, lookupEnvOrString("GITHUB_TOKEN", ""), "The GitHub Token to use for authentication.")
-	flag.StringVar(&c.TemplateFile, keyTemplateFile, lookupEnvOrString("TEMPLATE_FILE", "template/members.tpl"), "The template file to use for rendering the result.")
-	flag.StringVar(&c.OutputFile, keyOutputFile, lookupEnvOrString("OUTPUT_FILE", ""), "The output file to write the result to.")
-	flag.StringVar(&c.OwnDomains, keyOwnDomains, lookupEnvOrString("OWN_DOMAINS", ""), "The comma separated list of domains to consider as own domains.")
-	verbose := flag.Int("verbose", lookupEnvOrInt(keyVerbose, 0), "Verbosity level, 0=info, 1=debug. Overrides the environment variable VERBOSE.")
+	flag.StringVar(&c.Action, keyAction, lookupEnvOrString(kkeyActionEnvironment, ""), "The action to perform.")
+	flag.StringVar(&c.Enterprise, keyEnterprise, lookupEnvOrString(keyEnterpriseEnvironment, ""), "The GitHub Enterprise to query for repositories.")
+	flag.StringVar(&c.GithubToken, keyGithubToken, lookupEnvOrString(keyGithubTokenEnvironment, ""), "The GitHub Token to use for authentication.")
+	flag.StringVar(&c.TemplateFiles, keyTemplateFiles, lookupEnvOrString(keyTemplateFilesEnvironment, "template/members.tpl"), "The template file to use for rendering the result.")
+	flag.StringVar(&c.OutputFiles, keyOutputFiles, lookupEnvOrString(keyOutputFilesEnvironment, ""), "The output file to write the result to.")
+	flag.StringVar(&c.OwnDomains, keyOwnDomains, lookupEnvOrString(keyOwnDomainsEnvironment, ""), "The comma separated list of domains to consider as own domains.")
+	verbose := flag.Int(keyVerbose, lookupEnvOrInt(keyVerboseEnvironment, 0), "Verbosity level, 0=info, 1=debug. Overrides the environment variable VERBOSE.")
 
 	level := slog.LevelInfo
 	if *verbose > 0 {

main.go

@@ -18,8 +18,8 @@ func main() {
 		userlist.WithAction(c.Action),
 		userlist.WithEnterprise(c.Enterprise),
 		userlist.WithGithubToken(c.GithubToken),
-		userlist.WithTemplateFile(c.TemplateFile),
-		userlist.WithOutputFile(c.OutputFile),
+		userlist.WithTemplateFiles(c.TemplateFiles),
+		userlist.WithOutputFiles(c.OutputFiles),
 		userlist.WithOwnDomains(c.OwnDomains),
 	)
 

userlist/constructor.go

@@ -19,9 +19,9 @@ func WithAction(action string) func(*UserListConfig) {
 	}
 }
 
-func WithTemplateFile(templateFile string) func(*UserListConfig) {
+func WithTemplateFiles(templateFiles string) func(*UserListConfig) {
 	return func(config *UserListConfig) {
-		config.templateFile = templateFile
+		config.templateFiles = strings.Split(templateFiles, ",")
 	}
 }
 
@@ -37,9 +37,9 @@ func WithGithubToken(githubToken string) func(*UserListConfig) {
 	}
 }
 
-func WithOutputFile(outputFile string) func(*UserListConfig) {
+func WithOutputFiles(outputFiles string) func(*UserListConfig) {
 	return func(config *UserListConfig) {
-		config.outputFile = outputFile
+		config.outputFiles = strings.Split(outputFiles, ",")
 	}
 }
 

userlist/userlist.go

@@ -17,15 +17,15 @@ const (
 )
 
 type UserListConfig struct {
-	action       string
-	templateFile string
-	outputFile   string
-	enterprise   string
-	githubToken  string
-	validated    bool
-	loaded       bool
-	userList     UserList
-	ownDomains   []string
+	action        string
+	templateFiles []string
+	outputFiles   []string
+	enterprise    string
+	githubToken   string
+	validated     bool
+	loaded        bool
+	userList      UserList
+	ownDomains    []string
 }
 
 type UserList struct {
@@ -64,25 +64,29 @@ func (c *UserListConfig) Validate() error {
 	if c.action == "" {
 		return errors.New("Action is required")
 	}
-	if c.templateFile == "" {
+	if len(c.templateFiles) == 0 {
 		return errors.New("Template is required")
 	}
+	if len(c.outputFiles) == 0 {
+		return errors.New("Output File is required")
+	}
 	if c.enterprise == "" {
 		return errors.New("Enterprise is required")
 	}
 	if c.githubToken == "" {
 		return errors.New("Github Token is required")
 	}
-	if c.outputFile == "" {
-		return errors.New("Output File is required")
+	if len(c.templateFiles) != len(c.outputFiles) {
+		return errors.New("Template and Output Files must have the same length")
 	}
+
 	c.validated = true
 	slog.Debug("Validated userlist",
 		"action", c.action,
 		"enterprise", c.enterprise,
-		"template", c.templateFile,
+		"templateFiles", c.templateFiles,
 		"githubToken", "***",
-		"outputFile", c.outputFile,
+		"outputFiles", c.outputFiles,
 		slog.Any("ownDomains", c.ownDomains))
 	return nil
 }
@@ -120,25 +124,30 @@ func (ul *UserListConfig) Render() error {
 	if !ul.loaded {
 		return errors.New("UserList not loaded")
 	}
-	slog.Info("Rendering userlist", "template", ul.templateFile)
-	templateFile, err := os.ReadFile(ul.templateFile)
-	if err != nil {
-		slog.Error("Unable to read template file", "error", err, "file", ul.templateFile)
-		return err
-	}
 
-	tmpl := template.Must(template.New("userlist").Parse(string(templateFile)))
-	var buffer bytes.Buffer
-	err = tmpl.Execute(&buffer, ul.userList)
-	if err != nil {
-		slog.Error("Unable to render userlist", "error", err)
-		return err
-	}
+	for i, templateFileName := range ul.templateFiles {
+		outputFileName := ul.outputFiles[i]
 
-	err = os.WriteFile(ul.outputFile, buffer.Bytes(), 0644)
-	if err != nil {
-		slog.Error("Unable to write userlist", "error", err, "file", ul.outputFile)
-		return err
+		slog.Info("Rendering userlist", "templateFile", templateFileName, "outputFile", outputFileName)
+		templateFile, err := os.ReadFile(templateFileName)
+		if err != nil {
+			slog.Error("Unable to read template file", "error", err, "file", templateFileName)
+			return err
+		}
+
+		tmpl := template.Must(template.New("userlist").Parse(string(templateFile)))
+		var buffer bytes.Buffer
+		err = tmpl.Execute(&buffer, ul.userList)
+		if err != nil {
+			slog.Error("Unable to render userlist", "error", err)
+			return err
+		}
+
+		err = os.WriteFile(outputFileName, buffer.Bytes(), 0644)
+		if err != nil {
+			slog.Error("Unable to write userlist", "error", err, "file", outputFileName)
+			return err
+		}
 	}
 	return nil
 }