models/schema.go

package models
import (
	"google.golang.org/protobuf/reflect/protoreflect"
	"pro2d/common/components"
	"pro2d/common/db/mongoproxy"
	"pro2d/common/logger"
	"reflect"
	"strings"
)
type SchemaOption func(schema *Schema)
func WithSchemaDB(idb components.IDB) SchemaOption {
	return func(schema *Schema) {
		schema.db = idb
	}
}
type SchemaMap map[string]components.ISchema
type Schema struct {
	conn         components.IConnection
	db           components.IDB
	reflectValue *reflect.Value
	reflectIndex map[string]int
	cacheFields map[string]interface{}
	pri    interface{}
	schema interface{}
}
func NewSchema(key string, schema interface{}) *Schema {
	s := reflect.ValueOf(schema)
	if s.Kind() == reflect.Ptr {
		s = reflect.ValueOf(schema).Elem()
	}
	sch := &Schema{
		reflectValue: &s,
		cacheFields:  make(map[string]interface{}),
		schema:       schema,
		reflectIndex: make(map[string]int),
	}
	for i := 0; i < s.Type().NumField(); i++ {
		name := s.Type().Field(i).Name
		if strings.Compare(name[0:1], strings.ToLower(name[0:1])) == 0 {
			continue
		}
		sch.reflectIndex[strings.ToLower(strings.ToLower(name))] = i
	}
	sch.db = mongoproxy.NewMongoColl(sch.GetSchemaName(), sch)
	sch.pri = mongoproxy.GetBsonD(sch.getPriTag(), key)
	return sch
}
func (s *Schema) getPriTag() string {
	var pri string
	for i := 0; i < s.reflectValue.Type().NumField(); i++ {
		if s.reflectValue.Type().Field(i).Tag.Get("pri") == "1" {
			pri = strings.ToLower(s.reflectValue.Type().Field(i).Name)
			break
		}
	}
	return pri
}
func (s *Schema) FindIndex() (string, []string) {
	var index []string
	for i := 0; i < s.reflectValue.Type().NumField(); i++ {
		if s.reflectValue.Type().Field(i).Tag.Get("index") != "" {
			js := strings.Split(s.reflectValue.Type().Field(i).Tag.Get("json"), ",")
			if len(js) == 0 {
				continue
			}
			index = append(index, js[0])
		}
	}
	return strings.ToLower(s.reflectValue.Type().Name()), index
}
func (s *Schema) Init() {
	coll, keys := s.FindIndex()
	for _, index := range keys {
		s.db.CreateTable()
		logger.Debug("InitDoc collect: %v, createIndex: %s", coll, index)
		res, err := s.db.SetUnique(index)
		if err != nil {
			logger.Error("InitDoc unique: %s, err: %v", res, err)
			continue
		}
	}
}
func (s *Schema) GetDB() components.IDB {
	return s.db
}
func (s *Schema) GetPri() interface{} {
	return s.pri
}
func (s *Schema) GetSchema() interface{} {
	return s.schema
}
func (s *Schema) GetSchemaName() string {
	return strings.ToLower(s.reflectValue.Type().Name())
}
func (s *Schema) UpdateSchema(schema interface{}) {
	sch := reflect.ValueOf(schema)
	if sch.Kind() == reflect.Ptr {
		sch = reflect.ValueOf(schema).Elem()
	}
	for i := 0; i < sch.Type().NumField(); i++ {
		name := sch.Type().Field(i).Name
		if _, ok := s.reflectIndex[strings.ToLower(name)]; !ok {
			continue
		}
		s.SetProperty(sch.Type().Field(i).Name, sch.Field(i).Interface())
	}
}
func (s *Schema) SetConn(conn components.IConnection) {
	s.conn = conn
}
func (s *Schema) GetConn() components.IConnection {
	return s.conn
}
func (s *Schema) Load() error {
	return s.db.Load()
}
func (s *Schema) Create() error {
	_, err := s.db.Create()
	return err
}
//更新缓存字段到数据库
func (s *Schema) Update() {
	if len(s.cacheFields) > 0 {
		if err := s.db.UpdateProperties(s.cacheFields); err != nil {
			logger.Error("%s, UpdateErr: %s", s.GetSchemaName(), err.Error())
			return
		}
		s.cacheFields = make(map[string]interface{})
	}
}
//更新内存，并把字段缓存
func (s *Schema) SetProperty(key string, val interface{}) {
	idx, ok := s.reflectIndex[strings.ToLower(key)]
	if !ok {
		return
	}
	s.reflectValue.Field(idx).Set(reflect.ValueOf(val))
	s.cacheFields[strings.ToLower(key)] = val
}
//更新内存，并把字段缓存
func (s *Schema) SetProperties(properties map[string]interface{}) {
	for key, val := range properties {
		idx, ok := s.reflectIndex[strings.ToLower(key)]
		if !ok {
			continue
		}
		s.reflectValue.Field(idx).Set(reflect.ValueOf(val))
		s.cacheFields[strings.ToLower(key)] = val
	}
}
func (s *Schema) IncrProperty(key string, val int64) int64 {
	idx, ok := s.reflectIndex[strings.ToLower(key)]
	if !ok {
		return 0
	}
	field := s.reflectValue.Field(idx)
	var v int64
	switch field.Kind() {
	case reflect.Int64:
		v = field.Int() + val
	case reflect.Int:
		v = field.Int() + val
	}
	s.SetProperty(key, v)
	return v
}
func (s *Schema) ParseFields(message protoreflect.Message, properties map[string]interface{}) []int32 {
	ids := make([]int32, 0, len(properties))
	for k, v := range properties {
		field := message.Descriptor().Fields().ByName(protoreflect.Name(strings.ToLower(k)))
		if field == nil {
			continue
		}
		ids = append(ids, int32(field.Index()))
		message.Set(field, protoreflect.ValueOf(v))
		s.SetProperty(k, v)
	}
	return ids
}