从golang-gin-realworld-example-app项目学写httpapi (二)

https://github.com/gothinkster/golang-gin-realworld-example-app/blob/master/users/models.go

模型定义

users/models.go

package users

import (
	"errors"
	"github.com/jinzhu/gorm"
	"github.com/wangzitian0/golang-gin-starter-kit/common"
	"golang.org/x/crypto/bcrypt"
)

// UserModel对象，对应用户表
// gorm结构体标记，常用的column, type, size, primary_key, unique, index, unique_index, not null, -(忽略此字段)
type UserModel struct {
	ID           uint    `gorm:"primary_key"`
	Username     string  `gorm:"column:username"`
	Email        string  `gorm:"column:email;unique_index"`
	Bio          string  `gorm:"column:bio;size:1024"`
	Image        *string `gorm:"column:image"`
	PasswordHash string  `gorm:"column:password;not null"`
}

// FollowModel对象，对应关注表
// gorm.Model 是一个包含了基本字段的结构（struct）, 其中包括字段： ID、CreatedAt、UpdatedAt、DeletedAt（逻辑删除字段）
type FollowModel struct {
	gorm.Model
	Following    UserModel
	FollowingID  uint
	FollowedBy   UserModel
	FollowedByID uint
}

// 函数 用于创建表结构
// 如果不特别指定表名，以对象名大写单词拆分，用下划线连接，未尾加s 指定表名，如UserModel -> user_models
func AutoMigrate() {
    // 获取数据库连接
	db := common.GetDB()

    // 整合表结构，会创建新增的字段，不会改变原有字段内容，可以选择db.CreateTable代替
	db.AutoMigrate(&UserModel{})
	db.AutoMigrate(&FollowModel{})
	//db.CreateTable(&UserModel{})
	//db.CreateTable(&FollowModel{})
}

// UserModel对象的内置方法 用于设置密码， 使用 if err := user.setPassword("password0"); err !=nil { ... }
func (u *UserModel) setPassword(password string) error {
	if len(password) == 0 {
		return errors.New("password should not be empty!")
	}

	bytePassword := []byte(password)
	
    // `bcrypt generator cost` 取值 [4, 32] 间
	passwordHash, _ := bcrypt.GenerateFromPassword(bytePassword, bcrypt.DefaultCost)
	u.PasswordHash = string(passwordHash)
	return nil
}

// UserModel对象的内置方法 用于校验密码，使用 if err := user.checkPassword("password0"); err != nil { ... }
func (u *UserModel) checkPassword(password string) error {
	bytePassword := []byte(password)
	byteHashedPassword := []byte(u.PasswordHash)
        
    return bcrypt.CompareHashAndPassword(byteHashedPassword, bytePassword)
}

// UserModel对象相关的函数 用于查找符合条件的第一条记录，使用 user, err := FindOneUser(&UserModel{Username: "username0"})
func FindOneUser(condition interface{}) (UserModel, error) {
	db := common.GetDB()
	var model UserModel
    // condition使用Struct 或者 Map
	err := db.Where(condition).First(&model).Error
	return model, err
}

// UserModel对象相关的函数 用于插入记录，使用 if err := SaveOne(&userModel); err != nil { ... }
func SaveOne(data interface{}) error {
	db := common.GetDB()
	err := db.Save(data).Error
	//err := db.Create(data).Error
	return err
}

// UserModel对象的内置方法 用于更新记录，使用 if err := user.Update(UserModel{Username: "wangzitian0"}); err !=nil { ... }
func (model *UserModel) Update(data interface{}) error {
	db := common.GetDB()
	err := db.Model(model).Update(data).Error
	return err
}

// UserModel对象的内置方法 建立用户间关注（user1 -> user2），使用 if err := user1.following(user2); err != nil { ... }
func (u UserModel) following(v UserModel) error {
	db := common.GetDB()

	var follow FollowModel
    // 查询是否建立关注，如果没有则建立
	err := db.FirstOrCreate(&follow, &FollowModel{
		FollowingID:  v.ID,
		FollowedByID: u.ID,
	}).Error
	
    return err
}

// UserModel对象的内置方法 查询用户间是否关注（user1 -> user2），使用 if  ok := user1.isFollowing(user2); if ok { ... }
func (u UserModel) isFollowing(v UserModel) bool {
	db := common.GetDB()

	var follow FollowModel
	db.Where(FollowModel{
		FollowingID:  v.ID,
		FollowedByID: u.ID,
	}).First(&follow)

    // 查询是否关注，如果有关注，返回True(用户ID非0值)，没有关注（用户ID为0值）
	return follow.ID != 0
}

// UserModel对象的内置方法 取消用户间关注，使用 if err := user1.unFollowing(user2); err != nil { ... }
func (u UserModel) unFollowing(v UserModel) error {
	db := common.GetDB()

	err := db.Where(FollowModel{
		FollowingID:  v.ID,
		FollowedByID: u.ID,
	}).Delete(FollowModel{}).Error
	
    //因为FollowModel包含DeletedAt字段，此处为逻辑删除，实际执行的是 UPDATE follow_models SET deleted_at="2013-10-29 10:23" WHERE ...;
    return err
}

// UserModel对象的内置方法 查询指定用户的所有关注，使用 followings := user1.GetFollowings()
func (u UserModel) GetFollowings() []UserModel {
	db := common.GetDB()

    // 事务处理开始
	tx := db.Begin()
	var follows []FollowModel
	var followings []UserModel

    // 获取关注表里所有相关的关联记录
	tx.Where(FollowModel{
		FollowedByID: u.ID,
	}).Find(&follows)

    // 循环每条关联记录	
    for _, follow := range follows {
		var userModel UserModel
        // 第2参数Following为外键名
		tx.Model(&follow).Related(&userModel, "Following")
		followings = append(followings, userModel)
	}

    // 事务处理结束	
    tx.Commit()
	return followings
}