golib/infra/ii/svc/bootable/handler.go

package bootable

import (
	"strings"
	"time"

	"golib/features/mo"
	"golib/infra/ii"
)

var (
	fixedDayHour, _ = time.ParseDuration("23h59m59s999ms")
)

func (q *Filter) handleDateTime(matcher *mo.Matcher, field ii.FieldInfo, value interface{}) {
	switch v := value.(type) {
	case string:
		date, err := mo.ResolveDateTimeFrom(TimeLayout, v)
		if err != nil {
			return
		}
		dayEnd := mo.NewDateTimeFromTime(date.Time().Add(fixedDayHour))
		matcher.Gte(field.Name, date)
		matcher.Lte(field.Name, dayEnd)
	default:
		if t, err := field.Convert(value); err == nil {
			matcher.Gte(field.Name, t)
		}
	}
}

// handleSinglePoint 处理带 . 的字段查找
// 适用于 object 类型的查找
func (q *Filter) handleSinglePoint(reqName string, value interface{}, info *ii.ItemInfo, matcher *mo.Matcher) {
	fieldName, subFieldName, ok := strings.Cut(reqName, ".")
	if !ok {
		return
	}
	field, ok := info.Field(fieldName)
	if !ok {
		return
	}
	if !field.NoField {

	}
	subField, ok := field.SubField(subFieldName)
	if !ok {
		return
	}
	val, err := subField.Convert(value)
	if err != nil {
		return
	}
	switch field.Type {
	// 子 map 查找
	case mo.TypeObject:
		q.handleField(matcher, field, reqName, val, false)
	case mo.TypeArray:
		if field.Items != ii.FieldItemsObject {
			return
		}
		match := new(mo.Matcher)
		q.handleField(match, subField, subFieldName, val, false)
		q.handleField(matcher, field, fieldName, match, false)
	}
}

func (q *Filter) handleField(matcher *mo.Matcher, field ii.FieldInfo, key string, val interface{}, custom bool) {
	if custom {
		matcher.Add(key, val)
		return
	}
	// 详情见 ii utils.go 中 isEnabledType 已启用的类型
	switch field.Type {
	case mo.TypeString:
		// 字符串类型使用正则表达式搜索
		matcher.Regex(key, val)
	case mo.TypeDouble:
		matcher.Gte(key, val)
		matcher.Lte(key, val.(float64)+1)
	case mo.TypeLong:
		matcher.Gte(key, val)
	case mo.TypeArray:
		if field.Items == ii.FieldItemsObject {
			matcher.ElemMatch(key, val.(*mo.Matcher))
		} else {
			matcher.In(key, val.(mo.A))
		}
	default:
		matcher.Eq(key, val)
	}
}

func (q *Filter) handleParams(itemInfo *ii.ItemInfo, items ii.Items, matcher *mo.Matcher, doc mo.D, custom bool) {
	for _, ele := range doc {
		// 检查请求参数中的字段是否包含在 XML 配置文件中
		field, ok := itemInfo.Field(ele.Key)
		if !ok {
			switch strings.Count(ele.Key, ".") {
			case 1:
				q.handleSinglePoint(ele.Key, ele.Value, itemInfo, matcher)
			case 2:
				// lookup filter
				q.handle2Point(matcher, itemInfo, items, ele.Key, ele.Value)
			}
			continue
		}
		if field.Type == mo.TypeDate {
			q.handleDateTime(matcher, field, ele.Value)
			continue
		}
		// 将请求参数值转换为 XML 配置文件中的类型
		val, err := field.Convert(ele.Value)
		if err != nil {
			continue
		}
		q.handleField(matcher, field, ele.Key, val, custom)
	}
}