fastGin脚手架——命令行操作

package flags

import (
  "fast_gin/global"
  "flag"
  "fmt"
)

type FlagOptions struct {
  File    string
  Version bool
  DB      bool
}

var Options FlagOptions

func Parse() {
  flag.StringVar(&Options.File, "f", "settings.yaml", "配置文件路径")
  flag.BoolVar(&Options.Version, "v", false, "打印当前版本")
  flag.BoolVar(&Options.DB, "db", false, "迁移表结构")
  flag.Parse()
}

func Run() (ok bool) {
  if Options.DB {
    fmt.Println("表结构迁移")
    return true
  }
  if Options.Version {
    fmt.Println("当前后端版本", global.Version)
    return true
  }
  return false
}

通过flag内置库实现命令行参数绑定

可以通过 go run main.go -h 看到所有绑定的参数

然后我们还得实现，执行-v，-db之后不往下走

这一块也很简单，通过Parse和Run分开即可

package main

import (
  "fast_gin/core"
  "fast_gin/flags"
  "fast_gin/global"
  "fmt"
)

func main() {
  core.InitLogger()
  flags.Parse()
  global.Config = core.ReadConfig()
  global.DB = core.InitGorm()
  global.Redis = core.InitRedis()

  if flags.Run() {
    return
  }

  fmt.Println("web服务")
}

打印版本

有时候，想知道线上环境跑的是什么版本

可以通过命令行操作

func Run() (ok bool) {
  if Options.Version {
    fmt.Println("当前后端版本", global.Version)
    return true
  }
  return false
}

迁移表结构


func Run() {
  if Options.DB {
    MigrateDB()
    os.Exit(0)
  }
  if Options.Version {
    fmt.Println("当前后端版本", global.Version)
    os.Exit(0)
  }
}

表结构

type UserModel struct {
  Model
  Username string `gorm:"size:16" json:"username"`
  Nickname string `gorm:"size:32" json:"nickname"`
  Password string `gorm:"size:64" json:"password"`
  RoleID   int8   `json:"roleID"` // 1 管理员 2 普通用户
}

func MigrateDB() {
  err := global.DB.AutoMigrate(&models.UserModel{})
  if err != nil {
    logrus.Errorf("表结构迁移失败 %s", err)
    return
  }
  logrus.Infof("表结构迁移成功")
}

创建用户

通过命令行创建用户

package flags

import (
  "fast_gin/global"
  "fast_gin/models"
  "fast_gin/utils/pwd"
  "fmt"
  "github.com/sirupsen/logrus"
  "golang.org/x/crypto/ssh/terminal"
  "os"
)

type User struct {
}

func (User) Create() {
  var user models.UserModel
  fmt.Println("请选择角色： 1 管理员 2 普通用户")
  _, err := fmt.Scanln(&user.RoleID)
  if err != nil {
    fmt.Println("输入错误", err)
    return
  }
  if user.RoleID != 1 && user.RoleID != 2 {
    fmt.Println("用户角色输入错误", err)
    return
  }
  fmt.Println("请输入用户名")
  fmt.Scanln(&user.Username)

  var u models.UserModel
  err = global.DB.Take(&u, "username = ?", user.Username).Error
  if err == nil {
    fmt.Println("用户名已存在")
    return
  }

  fmt.Println("请输入密码")
  password, err := terminal.ReadPassword(int(os.Stdin.Fd())) // 读取用户输入的密码
  if err != nil {
    fmt.Println("读取密码时出错:", err)
    return
  }
  fmt.Println("请再次输入密码")
  rePassword, err := terminal.ReadPassword(int(os.Stdin.Fd())) // 读取用户输入的密码
  if err != nil {
    fmt.Println("读取密码时出错:", err)
    return
  }
  if string(password) != string(rePassword) {
    fmt.Println("两次密码不一致")
    return
  }

  hashPwd := pwd.GenerateFromPassword(string(password))
  err = global.DB.Create(&models.UserModel{
    Username: user.Username,
    Password: hashPwd,
    RoleID:   user.RoleID,
  }).Error
  if err != nil {
    logrus.Errorf("用户创建失败 %s", err)
    return
  }
  logrus.Infof("用户创建成功")

}
func (User) List() {
  var userList []models.UserModel
  global.DB.Order("created_at desc").Limit(10).Find(&userList)
  for _, model := range userList {
    fmt.Printf("用户id：%d  用户名：%s 用户昵称：%s 用户角色：%d 创建时间：%s\n",
      model.ID,
      model.Username,
      model.Nickname,
      model.RoleID,
      model.CreatedAt.Format("2006-01-02 15:04:05"),
    )
  }
}