370 lines
9.2 KiB
Go
370 lines
9.2 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"text/tabwriter"
|
|
"time"
|
|
|
|
"git.warky.dev/wdevs/whatshooked/pkg/config"
|
|
"git.warky.dev/wdevs/whatshooked/pkg/models"
|
|
"git.warky.dev/wdevs/whatshooked/pkg/storage"
|
|
resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
|
|
"github.com/google/uuid"
|
|
"github.com/spf13/cobra"
|
|
"golang.org/x/crypto/bcrypt"
|
|
"golang.org/x/term"
|
|
)
|
|
|
|
var serverConfigPath string
|
|
|
|
var usersCmd = &cobra.Command{
|
|
Use: "users",
|
|
Short: "Manage users (direct DB access)",
|
|
PersistentPreRun: func(cmd *cobra.Command, args []string) {
|
|
initUserDB()
|
|
},
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
listUsers()
|
|
},
|
|
}
|
|
|
|
var usersListCmd = &cobra.Command{
|
|
Use: "list",
|
|
Short: "List all users",
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
listUsers()
|
|
},
|
|
}
|
|
|
|
var usersAddCmd = &cobra.Command{
|
|
Use: "add",
|
|
Short: "Add a new user",
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
addUser()
|
|
},
|
|
}
|
|
|
|
var usersSetPasswordCmd = &cobra.Command{
|
|
Use: "set-password <username>",
|
|
Short: "Change a user's password",
|
|
Args: cobra.ExactArgs(1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
setPassword(args[0])
|
|
},
|
|
}
|
|
|
|
var usersDisableCmd = &cobra.Command{
|
|
Use: "disable <username>",
|
|
Short: "Disable a user account",
|
|
Args: cobra.ExactArgs(1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
setUserActive(args[0], false)
|
|
},
|
|
}
|
|
|
|
var usersEnableCmd = &cobra.Command{
|
|
Use: "enable <username>",
|
|
Short: "Enable a user account",
|
|
Args: cobra.ExactArgs(1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
setUserActive(args[0], true)
|
|
},
|
|
}
|
|
|
|
var usersUpdateCmd = &cobra.Command{
|
|
Use: "update <username>",
|
|
Short: "Update a user's details",
|
|
Args: cobra.ExactArgs(1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
updateUser(args[0])
|
|
},
|
|
}
|
|
|
|
var usersDeleteCmd = &cobra.Command{
|
|
Use: "delete <username>",
|
|
Short: "Delete a user",
|
|
Args: cobra.ExactArgs(1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
deleteUser(args[0])
|
|
},
|
|
}
|
|
|
|
var usersRemoveCmd = &cobra.Command{
|
|
Use: "remove <username>",
|
|
Short: "Remove a user (alias for delete)",
|
|
Args: cobra.ExactArgs(1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
deleteUser(args[0])
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
usersCmd.PersistentFlags().StringVar(&serverConfigPath, "server-config", "", "server config file (default: config.json or ~/.whatshooked/config.json)")
|
|
usersCmd.AddCommand(usersListCmd)
|
|
usersCmd.AddCommand(usersAddCmd)
|
|
usersCmd.AddCommand(usersUpdateCmd)
|
|
usersCmd.AddCommand(usersSetPasswordCmd)
|
|
usersCmd.AddCommand(usersDisableCmd)
|
|
usersCmd.AddCommand(usersEnableCmd)
|
|
usersCmd.AddCommand(usersDeleteCmd)
|
|
usersCmd.AddCommand(usersRemoveCmd)
|
|
}
|
|
|
|
func resolveServerConfigPath() string {
|
|
if serverConfigPath != "" {
|
|
return serverConfigPath
|
|
}
|
|
if _, err := os.Stat("config.json"); err == nil {
|
|
return "config.json"
|
|
}
|
|
home, err := os.UserHomeDir()
|
|
if err == nil {
|
|
p := filepath.Join(home, ".whatshooked", "config.json")
|
|
if _, err := os.Stat(p); err == nil {
|
|
return p
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func initUserDB() {
|
|
cfgPath := resolveServerConfigPath()
|
|
if cfgPath == "" {
|
|
fmt.Fprintln(os.Stderr, "Error: server config not found. Use --server-config to specify path.")
|
|
os.Exit(1)
|
|
}
|
|
cfg, err := config.Load(cfgPath)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error loading server config %s: %v\n", cfgPath, err)
|
|
os.Exit(1)
|
|
}
|
|
if err := storage.Initialize(&cfg.Database); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error connecting to database: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func listUsers() {
|
|
var users []models.ModelPublicUsers
|
|
err := storage.DB.NewSelect().Model(&users).OrderExpr("created_at ASC").Scan(context.Background())
|
|
checkError(err)
|
|
|
|
if len(users) == 0 {
|
|
fmt.Println("No users found")
|
|
return
|
|
}
|
|
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
|
|
fmt.Fprintln(w, "USERNAME\tEMAIL\tFULL NAME\tROLE\tACTIVE\tCREATED")
|
|
for _, u := range users {
|
|
active := "yes"
|
|
if !u.Active {
|
|
active = "no"
|
|
}
|
|
created := fmt.Sprint(u.CreatedAt)
|
|
if len(created) > 10 {
|
|
created = created[:10]
|
|
}
|
|
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n",
|
|
u.Username.String(),
|
|
u.Email.String(),
|
|
u.FullName.String(),
|
|
u.Role.String(),
|
|
active,
|
|
created,
|
|
)
|
|
}
|
|
w.Flush()
|
|
}
|
|
|
|
func addUser() {
|
|
scanner := bufio.NewScanner(os.Stdin)
|
|
|
|
fmt.Print("Username: ")
|
|
scanner.Scan()
|
|
username := strings.TrimSpace(scanner.Text())
|
|
if username == "" {
|
|
fmt.Fprintln(os.Stderr, "Error: username is required")
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Print("Email: ")
|
|
scanner.Scan()
|
|
email := strings.TrimSpace(scanner.Text())
|
|
if email == "" {
|
|
fmt.Fprintln(os.Stderr, "Error: email is required")
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Print("Full Name (optional): ")
|
|
scanner.Scan()
|
|
fullName := strings.TrimSpace(scanner.Text())
|
|
|
|
fmt.Print("Role (admin/user) [user]: ")
|
|
scanner.Scan()
|
|
role := strings.TrimSpace(scanner.Text())
|
|
if role == "" {
|
|
role = "user"
|
|
}
|
|
|
|
password := readPassword("Password: ")
|
|
if password == "" {
|
|
fmt.Fprintln(os.Stderr, "Error: password is required")
|
|
os.Exit(1)
|
|
}
|
|
|
|
hashedPw, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
|
|
checkError(err)
|
|
|
|
now := time.Now()
|
|
user := &models.ModelPublicUsers{
|
|
ID: resolvespec_common.NewSqlString(uuid.New().String()),
|
|
Username: resolvespec_common.NewSqlString(username),
|
|
Email: resolvespec_common.NewSqlString(email),
|
|
FullName: resolvespec_common.NewSqlString(fullName),
|
|
Role: resolvespec_common.NewSqlString(role),
|
|
Password: resolvespec_common.NewSqlString(string(hashedPw)),
|
|
Active: true,
|
|
CreatedAt: resolvespec_common.NewSqlTimeStamp(now),
|
|
UpdatedAt: resolvespec_common.NewSqlTimeStamp(now),
|
|
}
|
|
|
|
_, err = storage.DB.NewInsert().Model(user).Exec(context.Background())
|
|
checkError(err)
|
|
|
|
fmt.Printf("User '%s' created\n", username)
|
|
}
|
|
|
|
func setPassword(username string) {
|
|
user := findUserByUsername(username)
|
|
|
|
password := readPassword("New password: ")
|
|
confirm := readPassword("Confirm password: ")
|
|
if password != confirm {
|
|
fmt.Fprintln(os.Stderr, "Error: passwords do not match")
|
|
os.Exit(1)
|
|
}
|
|
if password == "" {
|
|
fmt.Fprintln(os.Stderr, "Error: password cannot be empty")
|
|
os.Exit(1)
|
|
}
|
|
|
|
hashedPw, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
|
|
checkError(err)
|
|
|
|
_, err = storage.DB.NewUpdate().Model(user).
|
|
Set("password = ?", string(hashedPw)).
|
|
Set("updated_at = ?", time.Now()).
|
|
Where("id = ?", user.ID.String()).
|
|
Exec(context.Background())
|
|
checkError(err)
|
|
|
|
fmt.Printf("Password updated for '%s'\n", username)
|
|
}
|
|
|
|
func setUserActive(username string, active bool) {
|
|
user := findUserByUsername(username)
|
|
|
|
_, err := storage.DB.NewUpdate().Model(user).
|
|
Set("active = ?", active).
|
|
Set("updated_at = ?", time.Now()).
|
|
Where("id = ?", user.ID.String()).
|
|
Exec(context.Background())
|
|
checkError(err)
|
|
|
|
state := "enabled"
|
|
if !active {
|
|
state = "disabled"
|
|
}
|
|
fmt.Printf("User '%s' %s\n", username, state)
|
|
}
|
|
|
|
func updateUser(username string) {
|
|
user := findUserByUsername(username)
|
|
scanner := bufio.NewScanner(os.Stdin)
|
|
|
|
fmt.Printf("Updating user '%s' (press Enter to keep current value)\n", username)
|
|
|
|
fmt.Printf("Username [%s]: ", user.Username.String())
|
|
scanner.Scan()
|
|
if v := strings.TrimSpace(scanner.Text()); v != "" {
|
|
user.Username = resolvespec_common.NewSqlString(v)
|
|
}
|
|
|
|
fmt.Printf("Email [%s]: ", user.Email.String())
|
|
scanner.Scan()
|
|
if v := strings.TrimSpace(scanner.Text()); v != "" {
|
|
user.Email = resolvespec_common.NewSqlString(v)
|
|
}
|
|
|
|
fmt.Printf("Full Name [%s]: ", user.FullName.String())
|
|
scanner.Scan()
|
|
if v := strings.TrimSpace(scanner.Text()); v != "" {
|
|
user.FullName = resolvespec_common.NewSqlString(v)
|
|
}
|
|
|
|
fmt.Printf("Role (admin/user) [%s]: ", user.Role.String())
|
|
scanner.Scan()
|
|
if v := strings.TrimSpace(scanner.Text()); v != "" {
|
|
user.Role = resolvespec_common.NewSqlString(v)
|
|
}
|
|
|
|
user.UpdatedAt = resolvespec_common.NewSqlTimeStamp(time.Now())
|
|
|
|
_, err := storage.DB.NewUpdate().Model(user).
|
|
Set("username = ?", user.Username.String()).
|
|
Set("email = ?", user.Email.String()).
|
|
Set("full_name = ?", user.FullName.String()).
|
|
Set("role = ?", user.Role.String()).
|
|
Set("updated_at = ?", time.Now()).
|
|
Where("id = ?", user.ID.String()).
|
|
Exec(context.Background())
|
|
checkError(err)
|
|
|
|
fmt.Printf("User '%s' updated\n", user.Username.String())
|
|
}
|
|
|
|
func deleteUser(username string) {
|
|
user := findUserByUsername(username)
|
|
|
|
fmt.Printf("Delete user '%s'? This cannot be undone. [y/N]: ", username)
|
|
scanner := bufio.NewScanner(os.Stdin)
|
|
scanner.Scan()
|
|
if strings.ToLower(strings.TrimSpace(scanner.Text())) != "y" {
|
|
fmt.Println("Cancelled")
|
|
return
|
|
}
|
|
|
|
_, err := storage.DB.NewDelete().Model(user).Where("id = ?", user.ID.String()).Exec(context.Background())
|
|
checkError(err)
|
|
|
|
fmt.Printf("User '%s' deleted\n", username)
|
|
}
|
|
|
|
func findUserByUsername(username string) *models.ModelPublicUsers {
|
|
var user models.ModelPublicUsers
|
|
err := storage.DB.NewSelect().Model(&user).Where("username = ?", username).Scan(context.Background())
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error: user '%s' not found\n", username)
|
|
os.Exit(1)
|
|
}
|
|
return &user
|
|
}
|
|
|
|
func readPassword(prompt string) string {
|
|
fmt.Print(prompt)
|
|
pw, err := term.ReadPassword(int(os.Stdin.Fd()))
|
|
fmt.Println()
|
|
if err != nil {
|
|
scanner := bufio.NewScanner(os.Stdin)
|
|
scanner.Scan()
|
|
return strings.TrimSpace(scanner.Text())
|
|
}
|
|
return string(pw)
|
|
}
|