PR Feedback:

* Move into milmove gen as a subcommand
* Add migration to manifest
* Create an empty local_migration

Makefile

@@ -241,9 +241,6 @@ bin/load-office-data: .server_generate.stamp
 bin/load-user-gen: .server_generate.stamp
 	go build -ldflags "$(LDFLAGS)" -o bin/load-user-gen ./cmd/load_user_gen
 
-bin/make-office-users-migration: .server_generate.stamp
-	go build -ldflags "$(LDFLAGS)" -o bin/make_office_users_migration ./cmd/make_office_users_migration
-
 bin/make-dps-user: .server_generate.stamp
 	go build -ldflags "$(LDFLAGS)" -o bin/make-dps-user ./cmd/make_dps_user
 
@@ -361,7 +358,6 @@ build_tools: server_deps \
 	bin/load-user-gen \
 	bin/make-dps-user \
 	bin/make-office-user \
-	bin/make-office-users-migration \
 	bin/make-tsp-user \
 	bin/renderer \
 	bin/save-fuel-price-data \

cmd/milmove/gen_migration.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"io/ioutil"
+	"log"
 	"os"
 	"path/filepath"
 	"strings"
@@ -41,6 +42,22 @@ func checkGenMigrationConfig(v *viper.Viper) error {
 	return nil
 }
 
+func addMigrationToManifest(migrationManifest string, filename string) error {
+	mmf, err := os.OpenFile(migrationManifest, os.O_APPEND|os.O_WRONLY, 0600)
+	if err != nil {
+		return errors.Wrap(err, "could not open migration manifest")
+	}
+	defer mmf.Close()
+
+	_, err = mmf.WriteString(filename + "\n")
+	if err != nil {
+		return errors.Wrap(err, "could not append to the migration manifest")
+	}
+
+	log.Println(fmt.Sprintf("new migration appended to manifest at %q", migrationManifest))
+	return nil
+}
+
 func genMigrationFunction(cmd *cobra.Command, args []string) error {
 
 	err := cmd.ParseFlags(args)
@@ -79,18 +96,9 @@ func genMigrationFunction(cmd *cobra.Command, args []string) error {
 
 	fmt.Println(fmt.Sprintf("new migration file created at %q", p))
 
-	mmf, err := os.OpenFile(migrationManifest, os.O_APPEND|os.O_WRONLY, 0600)
-	if err != nil {
-		return errors.Wrap(err, "could not open migration manifest")
-	}
-	defer mmf.Close()
-
-	_, err = mmf.WriteString(filename + "\n")
+	err = addMigrationToManifest(migrationManifest, filename)
 	if err != nil {
-		return errors.Wrap(err, "could not append to the migration manifest")
+		return err
 	}
-
-	fmt.Println(fmt.Sprintf("new migration appended to manifest at %q", migrationManifest))
-
 	return nil
 }

cmd/make_office_users_migration/main.go → cmd/milmove/gen_office_user_migration.go

@@ -12,6 +12,9 @@ import (
 	"text/template"
 	"time"
 
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+
 	"github.com/gobuffalo/validate"
 	"github.com/gobuffalo/validate/validators"
 
@@ -65,12 +68,18 @@ func CheckAddOfficeUsers(v *viper.Viper) error {
 	return nil
 }
 
-func initFlags(flag *pflag.FlagSet) {
+func initGenOffierUserMigrationFlags(flag *pflag.FlagSet) {
 	// Verbose
 	cli.InitVerboseFlags(flag)
 
+	// Migration Config
+	cli.InitMigrationFlags(flag)
+
 	// Add Office Users
 	InitAddOfficeUsersFlags(flag)
+
+	// Sort command line flags
+	flag.SortFlags = true
 }
 
 func ValidateOfficeUser(o *models.OfficeUser) (*validate.Errors, error) {
@@ -144,55 +153,70 @@ func closeFile(outfile *os.File) {
 	}
 }
 
-func main() {
-	flag := pflag.CommandLine
-	initFlags(flag)
-	err := flag.Parse(os.Args[1:])
+func createMigration(path string, filename string, t *template.Template, templateData interface{}) error {
+	migrationPath := filepath.Join(path, filename)
+	migrationFile, err := os.Create(migrationPath)
+	defer closeFile(migrationFile)
 	if err != nil {
-		log.Fatal(err)
+		return errors.Wrapf(err, "error creating %s", migrationPath)
+	}
+	err = t.Execute(migrationFile, templateData)
+	if err != nil {
+		log.Println("error executing template: ", err)
+	}
+	log.Printf("new migration file created at:  %q\n", migrationPath)
+	return nil
+}
+
+func genOfficeUserMigration(cmd *cobra.Command, args []string) error {
+	err := cmd.ParseFlags(args)
+	flag := cmd.Flags()
+	err = flag.Parse(os.Args[1:])
+	if err != nil {
+		return errors.Wrap(err, "could not parse flags")
 	}
 	v := viper.New()
 	err = v.BindPFlags(flag)
 	if err != nil {
-		log.Fatal(err)
+		return errors.Wrap(err, "could not bind flags")
 	}
 	err = CheckAddOfficeUsers(v)
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
+	migrationsPath := v.GetString(cli.MigrationPathFlag)
+	migrationManifest := v.GetString(cli.MigrationManifestFlag)
 	officeUsersFileName := v.GetString(OfficeUsersFilenameFlag)
 	migrationFileName := v.GetString(OfficeUsersMigrationFilenameFlag)
 
 	officeUsers, err := readOfficeUsersCSV(officeUsersFileName)
 	if err != nil {
-		log.Fatal("error reading csv file: ", err)
+		return errors.Wrap(err, "error reading csv file")
 	}
 
 	secureMigrationName := fmt.Sprintf("%s_%s.up.sql", time.Now().Format(VersionTimeFormat), migrationFileName)
-	secureMigrationPath := filepath.Join("./tmp", secureMigrationName)
-	secureMigrationFile, err := os.Create(secureMigrationPath)
-	defer closeFile(secureMigrationFile)
+	t1 := template.Must(template.New("add_office_user").Parse(createOfficeUser))
+	err = createMigration("./tmp", secureMigrationName, t1, officeUsers)
 	if err != nil {
-		log.Fatalf("error creating %s: %v\n", secureMigrationPath, err)
+		return err
 	}
-	t1 := template.Must(template.New("add_office_user").Parse(createOfficeUser))
-	err = t1.Execute(secureMigrationFile, officeUsers)
+	localMigrationPath := filepath.Join("local_migrations", secureMigrationName)
+	localMigrationFile, err := os.Create(localMigrationPath)
+	defer closeFile(localMigrationFile)
 	if err != nil {
-		log.Println("error executing template: ", err)
+		return errors.Wrapf(err, "error creating %s", localMigrationPath)
 	}
-	log.Printf("new secure migration file created at:  %q\n", secureMigrationPath)
 
 	migrationName := fmt.Sprintf("%s_%s.up.fizz", time.Now().Format(VersionTimeFormat), migrationFileName)
-	migrationPath := filepath.Join("./migrations", migrationName)
-	migrationFile, err := os.Create(migrationPath)
-	defer closeFile(migrationFile)
+	t2 := template.Must(template.New("migration").Parse(migration))
+	err = createMigration(migrationsPath, migrationName, t2, secureMigrationName)
 	if err != nil {
-		log.Fatalf("error creating %s: %v\n", migrationPath, err)
+		return err
 	}
-	t2 := template.Must(template.New("migration").Parse(migration))
-	err = t2.Execute(migrationFile, secureMigrationName)
+
+	err = addMigrationToManifest(migrationManifest, migrationName)
 	if err != nil {
-		log.Println("error executing template: ", err)
+		return err
 	}
-	log.Printf("new migration file created at:  %q\n", migrationPath)
+	return nil
 }

cmd/milmove/main.go

@@ -74,6 +74,17 @@ func main() {
 	initGenMigrationFlags(genMigrationCommand.Flags())
 	genCommand.AddCommand(genMigrationCommand)
 
+	genOfficerUserMigrationCommand := &cobra.Command{
+		Use:                   "officer_user_migration -f CSV_FILENAME -n MIGRATION_NAME",
+		Short:                 "Generate migrations required for adding office users",
+		Long:                  "Generate migrations required for adding office users",
+		RunE:                  genOfficeUserMigration,
+		DisableFlagsInUseLine: true,
+		SilenceErrors:         true, // not needed
+	}
+	initGenOffierUserMigrationFlags(genOfficerUserMigrationCommand.Flags())
+	genCommand.AddCommand(genOfficerUserMigrationCommand)
+
 	completionCommand := &cobra.Command{
 		Use:   "completion",
 		Short: "Generates bash completion scripts",