baize/framework/core/domain/object.go

package domain

import (
	"git.sxidc.com/go-framework/baize/framework/core/tag/check"
	"git.sxidc.com/go-tools/utils/reflectutils"
	"git.sxidc.com/go-tools/utils/strutils"
	"git.sxidc.com/go-tools/utils/template"
	"github.com/iancoleman/strcase"
	"github.com/pkg/errors"
	"reflect"
)

// Object 领域对象接口
type Object interface {
	// DBSchema 返回针对领域的数据库的schema，一般不需要赋值，除非该领域对象与其他领域对象不在同一个schema
	DBSchema() string

	// DomainCNName 返回领域的中文名称
	DomainCNName() string

	// DomainCamelName 返回领域的大写驼峰式名称
	DomainCamelName() string
}

// HasField 校验领域对象中是否有某一个字段
// 参数:
// - object: 领域对象
// - fieldName: 字段名
// 返回值:
// - 是否存在
func HasField(object Object, fieldName string) bool {
	return hasField(object, fieldName)
}

// CheckField 校验领域对象某一字段的字段校验结果
// 参数:
// - result: 使用check.Struct返回的字段校验结果
// - domainCNName: 领域中文名，可以使用DomainCNName()方法的返回值
// - fieldName: 字段名
// 返回值:
// - 错误
func CheckField(result check.Result, domainCNName string, fieldName string) error {
	err := result.CheckFields(fieldName)
	if err != nil {
		return errors.New(domainCNName + ": " + err.Error())
	}

	return nil
}

// CheckFields 校验领域对象多个字段的字段校验结果
// 参数:
// - result: 使用check.Struct返回的字段校验结果
// - domainCNName: 领域中文名，可以使用DomainCNName()方法的返回值
// - fieldNames: 多个字段名
// 返回值:
// - 错误
func CheckFields(result check.Result, domainCNName string, fieldNames []string) error {
	err := result.CheckFields(fieldNames...)
	if err != nil {
		return errors.New(domainCNName + ":\n" + err.Error())
	}

	return nil
}

// SetField 设置领域对象对应字段的值
// 类型参数：
// - T: 字段值的类型
// 参数:
// - object: 领域对象
// - fieldName: 要设置值的字段名
// - value: 设置的值
// 返回值:
// - 错误
func SetField[T any](object Object, fieldName string, value T) error {
	if object == nil {
		return errors.New("领域对象为nil")
	}

	fieldValue, err := getFieldValue(object, fieldName)
	if err != nil {
		return err
	}

	if !fieldValue.IsValid() || !fieldValue.CanSet() {
		return errors.New("领域对象" + fieldValue.Type().String() + "的字段" + fieldName + "无法赋值")
	}

	fieldValue.Set(reflect.ValueOf(value))

	return nil
}

// Field 获取领域对象对应字段的值
// 类型参数：
// - T: 字段值的类型
// 参数:
// - object: 领域对象
// - fieldName: 要获取值的字段名
// 返回值:
// - 错误
func Field[T any](object Object, fieldName string) (T, error) {
	zero := reflectutils.Zero[T]()

	if object == nil {
		return zero, errors.New("领域对象为nil")
	}

	fieldValue, err := getFieldValue(object, fieldName)
	if err != nil {
		return zero, err
	}

	if !fieldValue.IsValid() {
		return zero, errors.New("领域对象" + fieldValue.Type().String() + "的字段" + fieldName + "无法赋值")
	}

	retValue, ok := fieldValue.Interface().(T)
	if !ok {
		return zero, errors.New("转换字段类型失败")
	}

	return retValue, nil
}

// ToConcrete 将领域对象转换为具体类型
// 类型参数：
// - T: 要转换到的类型
// 参数:
// - object: 领域对象
// 返回值:
// - 转换出的类型
// - 错误
func ToConcrete[T Object](object Object) (T, error) {
	zero := reflectutils.Zero[T]()

	if object == nil {
		return zero, errors.New("领域对象为nil")
	}

	concrete, ok := object.(T)
	if !ok {
		return zero, errors.New("领域对象转化失败")
	}

	return concrete, nil
}

// TableName 基于领域对象生成表名，实际是将领域对象的驼峰式名称转换为蛇形复数形式，如classes
// 参数:
// - schema: 数据库的schema，如果领域对象DBSchema()方法返回值不为空，则取代schema参数
// - object: 领域对象
// 返回值:
// - 表名
func TableName(schema string, object Object) string {
	if strutils.IsStringNotEmpty(object.DBSchema()) {
		schema = object.DBSchema()
	}

	if strutils.IsStringEmpty(schema) {
		return template.Plural(strcase.ToSnake(template.Id(object.DomainCamelName())))
	} else {
		return schema + "." + template.Plural(strcase.ToSnake(template.Id(object.DomainCamelName())))
	}
}

// RelationTableName 生成两个领域对象的关联表名，实际是将两个领域对象的驼峰式名称转换为蛇形并使用and连接，如:class_and_student
// 参数:
// - schema: 数据库的schema，如果schema为空，但是两个领域对象的DBSchema()方法返回值不为空切一致，则取代schema参数
// - left: 左领域对象
// - right: 右领域对象
// 返回值:
// - 关联表名
func RelationTableName(schema string, left Object, right Object) string {
	if strutils.IsStringNotEmpty(left.DBSchema()) && left.DBSchema() == right.DBSchema() {
		schema = left.DBSchema()
	}

	if strutils.IsStringEmpty(schema) {
		return strcase.ToSnake(template.Id(left.DomainCamelName())) + "_and_" + strcase.ToSnake(template.Id(right.DomainCamelName()))
	} else {
		return schema + "." + strcase.ToSnake(template.Id(left.DomainCamelName())) + "_and_" + strcase.ToSnake(template.Id(right.DomainCamelName()))
	}
}

// ColumnName 生成对应字段的列名，实际为字段名转换为蛇形，如StudentNum会转化为student_num
// 参数:
// - fieldName: 字段名
// 返回值:
// - 列名
func ColumnName(fieldName string) string {
	return strcase.ToSnake(template.Id(fieldName))
}

// RelationColumnName 基于领域对象生成关联列名，实际为字段名转换为蛇形后加_id，如Student生成的关联列名为student_id
// 参数:
// - object: 领域对象
// 返回值:
// - 关联列名
func RelationColumnName(object Object) string {
	return strcase.ToSnake(template.Id(object.DomainCamelName())) + "_id"
}

// RelativeDomainPath 基于领域对象生成领域URL路径，实际为字段名转换为左小写驼峰式前面加/，如Student生成的领域URL路径为/student
// 参数:
// - object: 领域对象
// 返回值:
// - 领域URL路径
func RelativeDomainPath(object Object) string {
	return "/" + strcase.ToLowerCamel(template.Id(object.DomainCamelName()))
}

// SnakeDomainName 基于领域对象生成蛇形领域名称，如Student生成的蛇形领域名称为/student
// 参数:
// - object: 领域对象
// 返回值:
// - 蛇形领域名称
func SnakeDomainName(object Object) string {
	return strcase.ToSnake(template.Id(object.DomainCamelName()))
}

func hasField(object Object, fieldName string) bool {
	if object == nil {
		return false
	}

	objectValue := reflect.ValueOf(object)
	if !reflectutils.IsValueStructOrStructPointer(objectValue) {
		return false
	}

	fieldValue := reflectutils.PointerValueElem(objectValue).FieldByName(fieldName)
	if !fieldValue.IsValid() {
		return false
	}

	return true
}

func getFieldValue(object Object, fieldName string) (*reflect.Value, error) {
	if object == nil {
		return nil, errors.New("领域对象为nil")
	}

	objectValue := reflect.ValueOf(object)

	if !reflectutils.IsValueStructOrStructPointer(objectValue) {
		return nil, errors.New("领域对象必须是结构或结构指针")
	}

	fieldValue := reflectutils.PointerValueElem(objectValue).FieldByName(fieldName)

	return &fieldValue, nil
}