Merge branch 'refactor' into 'main'

refactor: Reorganize into user and group commands

See merge request tss24/useradm!1

.gitignore

+useradm

cmd/create.go

-package cmd
-
-import (
-    "github.com/spf13/cobra"
-)
-
-var createConfirm bool
-
-var createCmd = &cobra.Command{
-    Use:   "create",
-    Short: "Create resources",
-}
-
-func init() {
-    rootCmd.AddCommand(createCmd)
-
-    createCmd.PersistentFlags().BoolVarP(
-        &createConfirm,
-        "confirm",
-        "y",
-        false,
-        "Skip confirmation prompt",
-    )
-}
-

cmd/create_group.go

-package cmd
-
-import (
-    "os"
-    "fmt"
-    "bufio"
-    "strings"
-
-    "github.com/spf13/cobra"
-)
-
-var groupName string
-
-var createGroupCmd = &cobra.Command{
-    Use:   "group",
-    Short: "Create a new group",
-    Run: func(cmd *cobra.Command, args []string) {
-
-        fmt.Printf("Groupname: %s\n", groupName)
-
-        // Confirmation logic
-        if !createConfirm {
-            fmt.Print("Proceed with group creation? [y/N] ")
-            reader := bufio.NewReader(os.Stdin)
-            response, _ := reader.ReadString('\n')
-            if strings.TrimSpace(strings.ToLower(response)) != "y" {
-                fmt.Println("Aborted.")
-                return
-            }
-        }
-
-        fmt.Println("Done!")
-    },
-}
-
-func init() {
-    createCmd.AddCommand(createGroupCmd)
-    
-    // Possible Flags
-    createGroupCmd.Flags().StringVarP(&groupName,    "groupname", "e", "", "Group name (use quotes for spaces)")
-    
-    // Required Flags
-    createGroupCmd.MarkFlagRequired("groupname")
-}
-

cmd/create_user.go

-package cmd
-
-import (
-    "os"
-    "fmt"
-    "bufio"
-    "strings"
-    
-    "github.com/spf13/cobra"
-)
-
-var (
-    userGrr         string
-    userLtype       string
-    userPath        string
-    userName        string
-    userLogin       string
-    userGroup       string
-    userShell       string
-    userHomedir     string
-    userPassword    string
-)
-
-var createUserCmd = &cobra.Command{
-    Use:   "user",
-    Short: "Create a new user",
-    Run: func(cmd *cobra.Command, args []string) {
-
-        // Build user info string
-        userInfo := fmt.Sprintf(
-            `User Configuration:
-Name:     %s
-Login:    %s
-Type:     %s
-Group:    %s
-Shell:    %s
-HomeDir:  %s
-Password: %s
-WebPath:  %s`,
-            userName,
-            ifThenElse(userLogin != "", userLogin, "[auto-generate]"),
-            userLtype,
-            userGroup,
-            userShell,
-            userHomedir,
-            ifThenElse(userPassword != "", "[set]", "[auto-generate]"),
-            userPath,
-        )
-
-        fmt.Println(userInfo)
-
-        // Confirmation logic
-        if !createConfirm {
-            fmt.Print("Proceed with user creation? [y/N] ")
-            reader := bufio.NewReader(os.Stdin)
-            response, _ := reader.ReadString('\n')
-            if strings.TrimSpace(strings.ToLower(response)) != "y" {
-                fmt.Println("Aborted.")
-                return
-            }
-        }
-
-        fmt.Println("Done!")
-    },
-}
-
-func init() {
-    createCmd.AddCommand(createUserCmd)
-    
-    // Possible Flags
-    createUserCmd.Flags().StringVarP(&userGrr,      "grr",      "r", "",          "User GRR, required for ini type")
-    createUserCmd.Flags().StringVarP(&userLtype,    "type",     "t", "ini",       "Type of auto-generated login: ini, first or last")
-    createUserCmd.Flags().StringVarP(&userPath,     "path",     "w", "",          "Path to webdir      (e.g. path/login)")
-    createUserCmd.Flags().StringVarP(&userName,     "name",     "n", "",          "User full name      (use quotes for spaces)")
-    createUserCmd.Flags().StringVarP(&userLogin,    "login",    "l", "",          "User login name     (auto-generated if empty)")
-    createUserCmd.Flags().StringVarP(&userGroup,    "group",    "g", "",          "User initial group")
-    createUserCmd.Flags().StringVarP(&userShell,    "shell",    "s", "/bin/bash", "Full path to shell ")
-    createUserCmd.Flags().StringVarP(&userHomedir,  "homedir",  "d", "",          "Home directory path (/home/group/login if empty)")
-    createUserCmd.Flags().StringVarP(&userPassword, "password", "p", "",          "User password       (auto-generated if empty)")
-    
-    // Required Flags
-    createUserCmd.MarkFlagRequired("name")
-    createUserCmd.MarkFlagRequired("type")
-    createUserCmd.MarkFlagRequired("group")
-}
-
-func ifThenElse(condition bool, a string, b string) string {
-    if condition {
-        return a
-    }
-    return b
-}
-

cmd/group.go

+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"gitlab.c3sl.ufpr.br/tss24/useradm/cmd/group"
+)
+
+var groupCmd = &cobra.Command{
+	Use:   "group",
+	Short: "User subcommand",
+}
+
+func init() {
+	groupCmd.AddCommand(group.CreateCmd)
+	groupCmd.AddCommand(group.DeleteCmd)
+}

cmd/group/create.go

+package group
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var CreateCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create new group",
+	RunE:  createGroupFunc,
+}
+
+func init() {
+	CreateCmd.Flags().StringP("groupname", "e", "", "Group name (use quotes for spaces)")
+	CreateCmd.Flags().BoolP("confirm", "y", false, "Skip confirmation prompt")
+
+	CreateCmd.MarkFlagRequired("groupname")
+}
+
+func createGroupFunc(cmd *cobra.Command, args []string) error {
+	groupName, err := cmd.Flags().GetString("groupname")
+	if err != nil {
+		return err
+	}
+	confirm, err := cmd.Flags().GetBool("confirm")
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Groupname: %s\n", groupName)
+
+	if !confirm {
+		fmt.Print("Proceed with group creation? [y/N] ")
+		reader := bufio.NewReader(os.Stdin)
+		response, _ := reader.ReadString('\n')
+		if strings.TrimSpace(strings.ToLower(response)) != "y" {
+			fmt.Println("Aborted.")
+			os.Exit(1)
+		}
+	}
+
+	fmt.Println("Done!")
+	return nil
+}

cmd/group/delete.go

+package group
+
+import "github.com/spf13/cobra"
+
+var DeleteCmd = &cobra.Command{
+	Use:   "delete",
+	Short: "Delete a group",
+	RunE:  deleteRun,
+}
+
+func deleteRun(cmd *cobra.Command, args []string) error {
+	return nil
+}

cmd/root.go

 package cmd
 
 import (
+	"fmt"
 	"os"
 
 	"github.com/spf13/cobra"
 )
 
-
-
 var rootCmd = &cobra.Command{
 	Use:   "useradm",
 	Short: "A CLI to help administrate the user account in DINF",
@@ -20,12 +19,12 @@ made as an update for the previous version.`,
 func Execute() {
 	err := rootCmd.Execute()
 	if err != nil {
+		fmt.Fprintf(os.Stderr, "cmd: %v", err)
 		os.Exit(1)
 	}
 }
 
 func init() {
-	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+	rootCmd.AddCommand(userCmd)
+	rootCmd.AddCommand(groupCmd)
 }
-
-

cmd/user.go

+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"gitlab.c3sl.ufpr.br/tss24/useradm/cmd/user"
+)
+
+var userCmd = &cobra.Command{
+	Use:   "user",
+	Short: "User subcommand",
+}
+
+func init() {
+	userCmd.AddCommand(user.CreateCmd)
+	userCmd.AddCommand(user.DeleteCmd)
+	userCmd.AddCommand(user.ModCmd)
+	userCmd.AddCommand(user.ShowCmd)
+}

cmd/user/create.go

+package user
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"gitlab.c3sl.ufpr.br/tss24/useradm/model"
+)
+
+var CreateCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create new user",
+	RunE:  createUserFunc,
+}
+
+func init() {
+	// Possible Flags
+	CreateCmd.Flags().StringP("grr", "r", "", "User GRR, required for ini type")
+	CreateCmd.Flags().StringP("type", "t", "ini", "Type of auto-generated login: ini, first or last")
+	CreateCmd.Flags().StringP("path", "w", "", "Path to webdir      (e.g. path/login)")
+	CreateCmd.Flags().StringP("name", "n", "", "User full name      (use quotes for spaces)")
+	CreateCmd.Flags().StringP("login", "l", "", "User login name     (auto-generated if empty)")
+	CreateCmd.Flags().StringP("group", "g", "", "User initial group")
+	CreateCmd.Flags().StringP("shell", "s", "/bin/bash", "Full path to shell ")
+	CreateCmd.Flags().StringP("homedir", "d", "", "Home directory path (/home/group/login if empty)")
+	CreateCmd.Flags().StringP("password", "p", "", "User password       (auto-generated if empty)")
+
+	// Required Flags
+	CreateCmd.MarkFlagRequired("name")
+	CreateCmd.MarkFlagRequired("type")
+	CreateCmd.MarkFlagRequired("group")
+
+	CreateCmd.Flags().BoolP("confirm", "y", false, "Skip confirmation prompt")
+}
+
+func createUserFunc(cmd *cobra.Command, args []string) error {
+	confirm, err := cmd.Flags().GetBool("confirm")
+	if err != nil {
+		return err
+	}
+	userName, err := cmd.Flags().GetString("name")
+	if err != nil {
+		return err
+	}
+	userType, err := cmd.Flags().GetString("type")
+	if err != nil {
+		return err
+	}
+	userGroup, err := cmd.Flags().GetString("group")
+	if err != nil {
+		return err
+	}
+	userGRR, err := cmd.Flags().GetString("grr")
+	if err != nil {
+		return err
+	}
+	userPath, err := cmd.Flags().GetString("path")
+	if err != nil {
+		return err
+	}
+	userLogin, err := cmd.Flags().GetString("login")
+	if err != nil {
+		return err
+	}
+	userShell, err := cmd.Flags().GetString("shell")
+	if err != nil {
+		return err
+	}
+	userHomedir, err := cmd.Flags().GetString("homedir")
+	if err != nil {
+		return err
+	}
+	userPassword, err := cmd.Flags().GetString("password")
+	if err != nil {
+		return err
+	}
+
+	user := model.User{
+		Name:     userName,
+		Ltype:    userType,
+		Group:    userGroup,
+		GRR:      userGRR,
+		Path:     userPath,
+		Login:    ifThenElse(userLogin != "", userLogin, "[auto-generate]"),
+		Shell:    userShell,
+		Homedir:  userHomedir,
+		Password: ifThenElse(userPassword != "", "[set]", "[auto-generate]"),
+	}
+
+	fmt.Println(user.ToString())
+
+	if !confirm {
+		fmt.Print("Proceed with user creation? [y/N] ")
+		reader := bufio.NewReader(os.Stdin)
+		response, _ := reader.ReadString('\n')
+		if strings.TrimSpace(strings.ToLower(response)) != "y" {
+			fmt.Fprintln(os.Stderr, "Aborted.")
+			os.Exit(1)
+		}
+	}
+
+	fmt.Println("Done!")
+
+	return nil
+}
+
+func ifThenElse(condition bool, a string, b string) string {
+	if condition {
+		return a
+	}
+	return b
+}

cmd/user/delete.go

+package user
+
+import "github.com/spf13/cobra"
+
+var DeleteCmd = &cobra.Command{
+	Use:   "delete",
+	Short: "Deleta a user",
+}

cmd/user/mod.go

+package user
+
+import "github.com/spf13/cobra"
+
+var ModCmd = &cobra.Command{
+	Use:   "mod",
+	Short: "Modify user information",
+}

cmd/user/show.go

+package user
+
+import "github.com/spf13/cobra"
+
+var ShowCmd = &cobra.Command{
+	Use:   "show",
+	Short: "Display user information",
+}

model/user.go

+package model
+
+import "fmt"
+
+type User struct {
+	GRR      string
+	Ltype    string
+	Path     string
+	Name     string
+	Login    string
+	Group    string
+	Shell    string
+	Homedir  string
+	Password string
+}
+
+func (u *User) ToString() string {
+	return fmt.Sprintf(`User:
+	Name:     %s
+	Login:    %s
+	Type:     %s
+	Group:    %s
+	Shell:    %s
+	HomeDir:  %s
+	Password: %s
+	WebPath:  %s`,
+		u.Name, u.Login, u.Ltype, u.Group, u.Shell, u.Homedir, u.Password, u.Path)
+}