BlackForestBytes/goext
19
0
Fork 0
Code Actions Activity

v0.0.147

Browse Source
This commit is contained in:
Mike Schwörer
2023-06-07 16:58:17 +02:00
parent c7df9d2264
commit 45d4fd7101
12 changed files with 365 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
wmo/collection.go
View File

@@ -13,6 +13,7 @@ type EntityID = any
type fullTypeRef[TData any] struct {
IsPointer bool
Kind reflect.Kind
RealType reflect.Type
Type reflect.Type
UnderlyingType reflect.Type
Name string

5
wmo/pagination.go
View File

@@ -1,6 +1,7 @@
package wmo
import (
"errors"
"go.mongodb.org/mongo-driver/bson"
ct "gogs.mikescher.com/BlackForestBytes/goext/cursortoken"
)
@@ -70,6 +71,10 @@ func CreatePagination[TData any](coll *Coll[TData], token ct.CursorToken, fieldP
// false
pipeline = append(pipeline, bson.D{{Key: "$match", Value: bson.M{"$eq": bson.A{"1", "0"}}}})
} else {
return nil, errors.New("unknown ct mode: " + string(token.Mode))
}
pipeline = append(pipeline, bson.D{{Key: "$sort", Value: sort}})

208
wmo/reflection.go
View File

@@ -1,12 +1,9 @@
package wmo
import (
"errors"
"fmt"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/reflectext"
"reflect"
"strconv"
"time"
)
func (c *Coll[TData]) init() {
@@ -48,9 +45,10 @@ func (c *Coll[TData]) initFields(prefix string, rval reflect.Value, idxarr []int
c.dataTypeMap[fullKey] = fullTypeRef[TData]{
IsPointer: true,
RealType: rvfield.Type(),
Kind: rvfield.Type().Elem().Kind(),
Type: rvfield.Type().Elem(),
UnderlyingType: langext.Underlying(rvfield.Type().Elem()),
UnderlyingType: reflectext.Underlying(rvfield.Type().Elem()),
Name: rsfield.Name,
Index: newIdxArr,
}
@@ -59,9 +57,10 @@ func (c *Coll[TData]) initFields(prefix string, rval reflect.Value, idxarr []int
c.dataTypeMap[fullKey] = fullTypeRef[TData]{
IsPointer: false,
RealType: rvfield.Type(),
Kind: rvfield.Type().Kind(),
Type: rvfield.Type(),
UnderlyingType: langext.Underlying(rvfield.Type()),
UnderlyingType: reflectext.Underlying(rvfield.Type()),
Name: rsfield.Name,
Index: newIdxArr,
}
@@ -77,210 +76,23 @@ func (c *Coll[TData]) initFields(prefix string, rval reflect.Value, idxarr []int
}
func (c *Coll[TData]) getTokenValueAsMongoType(value string, fieldName string) (any, error) {
fref := c.dataTypeMap[fieldName]
if fref.IsPointer && value == "" {
pointertype := reflect.New(fref.Type).Type()
nilvalue := reflect.Zero(pointertype)
outvalue := nilvalue.Interface()
return outvalue, nil
}
pss := reflectext.PrimitiveStringSerializer{}
pointerize := func(v any) any {
if !fref.IsPointer {
return v
}
return pss.ValueFromString(value, fref.RealType)
rval1 := reflect.ValueOf(v)
rval2 := rval1.Convert(fref.Type)
rval3 := reflect.New(fref.Type)
rval3.Elem().Set(rval2)
return rval3.Interface()
}
if fref.UnderlyingType == reflect.TypeOf("") {
rt, ok := langext.TryCastType(value, fref.Type)
if !ok {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from string to %s", fieldName, fref.Type.String()))
}
return pointerize(rt), nil
}
if fref.UnderlyingType == reflect.TypeOf(time.Time{}) {
t, err := time.Parse(time.RFC3339Nano, value)
if err != nil {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as time.Time ('%s')", fieldName, value))
}
rt, ok := langext.TryCastType(t, fref.Type)
if !ok {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from time.Time to %s", fieldName, fref.Type.String()))
}
return pointerize(rt), nil
}
if fref.UnderlyingType == reflect.TypeOf(int(0)) {
t, err := strconv.ParseInt(value, 10, 64)
if err != nil {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as int64 ('%s')", fieldName, value))
}
rt, ok := langext.TryCastType(int(t), fref.Type)
if !ok {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from int to %s", fieldName, fref.Type.String()))
}
return pointerize(rt), nil
}
if fref.UnderlyingType == reflect.TypeOf(int32(0)) {
t, err := strconv.ParseInt(value, 10, 64)
if err != nil {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as int32 ('%s')", fieldName, value))
}
rt, ok := langext.TryCastType(int32(t), fref.Type)
if !ok {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from int32 to %s", fieldName, fref.Type.String()))
}
return pointerize(rt), nil
}
if fref.UnderlyingType == reflect.TypeOf(int64(0)) {
t, err := strconv.ParseInt(value, 10, 64)
if err != nil {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as int64 ('%s')", fieldName, value))
}
rt, ok := langext.TryCastType(int64(t), fref.Type)
if !ok {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from int64 to %s", fieldName, fref.Type.String()))
}
return pointerize(rt), nil
}
if fref.UnderlyingType == reflect.TypeOf(float32(0)) {
t, err := strconv.ParseFloat(value, 64)
if err != nil {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as float32 ('%s')", fieldName, value))
}
rt, ok := langext.TryCastType(float32(t), fref.Type)
if !ok {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from float32 to %s", fieldName, fref.Type.String()))
}
return pointerize(rt), nil
}
if fref.UnderlyingType == reflect.TypeOf(float64(0)) {
t, err := strconv.ParseFloat(value, 64)
if err != nil {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as float64 ('%s')", fieldName, value))
}
rt, ok := langext.TryCastType(float64(t), fref.Type)
if !ok {
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from float64 to %s", fieldName, fref.Type.String()))
}
return pointerize(rt), nil
}
return nil, errors.New(fmt.Sprintf("failed to parse field '%s' of type %s (%s)", fieldName, fref.Type.String(), fref.UnderlyingType.String()))
}
func (c *Coll[TData]) getFieldValueAsTokenString(entity TData, fieldName string) (string, error) {
fref := c.dataTypeMap[fieldName]
realValue := c.getFieldValue(entity, fieldName)
if langext.IsNil(realValue) {
return "", nil
}
pss := reflectext.PrimitiveStringSerializer{}
reflValue := reflect.ValueOf(realValue)
if reflValue.Kind() == reflect.Pointer {
reflValue = reflValue.Elem()
realValue = reflValue.Interface()
}
return pss.ValueToString(realValue)
if fref.UnderlyingType == reflect.TypeOf("") {
rt, ok := langext.TryCastType(realValue, reflect.TypeOf(""))
if !ok {
return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to string", fieldName, fref.Type.String()))
}
return rt.(string), nil
}
if fref.UnderlyingType == reflect.TypeOf(time.Time{}) {
rt, ok := langext.TryCastType(realValue, reflect.TypeOf(time.Time{}))
if !ok {
return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to time.Time", fieldName, fref.Type.String()))
}
return rt.(time.Time).Format(time.RFC3339Nano), nil
}
if fref.UnderlyingType == reflect.TypeOf(int(0)) {
rt, ok := langext.TryCastType(realValue, reflect.TypeOf(int(0)))
if !ok {
return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to int", fieldName, fref.Type.String()))
}
return strconv.Itoa(rt.(int)), nil
}
if fref.UnderlyingType == reflect.TypeOf(int32(0)) {
rt, ok := langext.TryCastType(realValue, reflect.TypeOf(int32(0)))
if !ok {
return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to int32", fieldName, fref.Type.String()))
}
return strconv.FormatInt(int64(rt.(int32)), 10), nil
}
if fref.UnderlyingType == reflect.TypeOf(int64(0)) {
rt, ok := langext.TryCastType(realValue, reflect.TypeOf(int64(0)))
if !ok {
return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to int64", fieldName, fref.Type.String()))
}
return strconv.FormatInt(rt.(int64), 10), nil
}
if fref.UnderlyingType == reflect.TypeOf(float32(0)) {
rt, ok := langext.TryCastType(realValue, reflect.TypeOf(float32(0)))
if !ok {
return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to float32", fieldName, fref.Type.String()))
}
return strconv.FormatFloat(float64(rt.(float32)), 'f', -1, 32), nil
}
if fref.UnderlyingType == reflect.TypeOf(float64(0)) {
rt, ok := langext.TryCastType(realValue, reflect.TypeOf(float64(0)))
if !ok {
return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to float64", fieldName, fref.Type.String()))
}
return strconv.FormatFloat(rt.(float64), 'f', -1, 64), nil
}
return "", errors.New(fmt.Sprintf("failed to parse field '%s' of type %s (%s)", fieldName, fref.Type.String(), fref.UnderlyingType.String()))
}
func (c *Coll[TData]) getFieldType(fieldName string) fullTypeRef[TData] {

47
wmo/reflection_test.go
View File

@@ -3,6 +3,8 @@ package wmo
import (
"go.mongodb.org/mongo-driver/mongo"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
"gogs.mikescher.com/BlackForestBytes/goext/timeext"
"gogs.mikescher.com/BlackForestBytes/goext/tst"
"testing"
"time"
@@ -18,8 +20,9 @@ func TestReflectionGetFieldType(t *testing.T) {
Sub struct {
A string `bson:"a"`
} `bson:"sub"`
Str string `bson:"str"`
Ptr *int `bson:"ptr"`
Str string `bson:"str"`
Ptr *int `bson:"ptr"`
MDate rfctime.RFC3339NanoTime `bson:"mdate"`
}
coll := W[TestData](&mongo.Collection{})
@@ -27,6 +30,7 @@ func TestReflectionGetFieldType(t *testing.T) {
coll.init()
t0 := time.Now()
t1 := rfctime.NewRFC3339Nano(t0)
d := TestData{
ID: "1",
@@ -36,8 +40,9 @@ func TestReflectionGetFieldType(t *testing.T) {
}{
A: "2",
},
Str: "3",
Ptr: langext.Ptr(4),
Str: "3",
Ptr: langext.Ptr(4),
MDate: t1,
}
tst.AssertEqual(t, coll.getFieldType("_id").Kind.String(), "string")
@@ -81,9 +86,10 @@ func TestReflectionGetTokenValueAsMongoType(t *testing.T) {
Sub struct {
A string `bson:"a"`
} `bson:"sub"`
Str string `bson:"str"`
Ptr *int `bson:"ptr"`
Num int `bson:"num"`
Str string `bson:"str"`
Ptr *int `bson:"ptr"`
Num int `bson:"num"`
MDate rfctime.RFC3339NanoTime `bson:"mdate"`
}
coll := W[TestData](&mongo.Collection{})
@@ -94,15 +100,23 @@ func TestReflectionGetTokenValueAsMongoType(t *testing.T) {
v, err := coll.getTokenValueAsMongoType(value, fieldName)
if err != nil {
t.Errorf("%s", "failed to getTokenValueAsMongoType")
t.Errorf("%v+", err)
}
return v
}
tx, err := time.Parse(time.RFC3339Nano, "2009-11-10T23:00:00Z")
if err != nil {
t.Errorf("%v", err)
}
tst.AssertEqual(t, gtvasmt("hello", "str").(string), "hello")
tst.AssertEqual(t, gtvasmt("4", "num").(int), 4)
tst.AssertEqual(t, gtvasmt("asdf", "_id").(IDType), "asdf")
tst.AssertEqual(t, gtvasmt("", "ptr").(*int), nil)
tst.AssertEqual(t, *(gtvasmt("123", "ptr").(*int)), 123)
tst.AssertEqual(t, gtvasmt("2009-11-10T23:00:00Z", "cdate").(time.Time), tx)
tst.AssertEqual(t, gtvasmt("2009-11-10T23:00:00Z", "mdate").(rfctime.RFC3339NanoTime), rfctime.NewRFC3339Nano(tx))
}
func TestReflectionGetFieldValueAsTokenString(t *testing.T) {
@@ -115,22 +129,25 @@ func TestReflectionGetFieldValueAsTokenString(t *testing.T) {
Sub struct {
A string `bson:"a"`
} `bson:"sub"`
Str string `bson:"str"`
Ptr *int `bson:"ptr"`
Num int `bson:"num"`
Ptr2 *int `bson:"ptr2"`
FFF float64 `bson:"fff"`
Str string `bson:"str"`
Ptr *int `bson:"ptr"`
Num int `bson:"num"`
Ptr2 *int `bson:"ptr2"`
FFF float64 `bson:"fff"`
MDate rfctime.RFC3339NanoTime `bson:"mdate"`
}
coll := W[TestData](&mongo.Collection{})
coll.init()
t0 := time.Now()
t0 := time.Date(2000, 1, 1, 12, 0, 0, 0, timeext.TimezoneBerlin)
t1 := rfctime.NewRFC3339Nano(t0)
d := TestData{
ID: "1",
CDate: t0,
MDate: t1,
Sub: struct {
A string `bson:"a"`
}{
@@ -146,7 +163,7 @@ func TestReflectionGetFieldValueAsTokenString(t *testing.T) {
gfvats := func(value TestData, fieldName string) string {
v, err := coll.getFieldValueAsTokenString(value, fieldName)
if err != nil {
t.Errorf("%s", "failed to getTokenValueAsMongoType")
t.Errorf("%s: %v", "failed to getTokenValueAsMongoType", err)
}
return v
}
@@ -157,4 +174,6 @@ func TestReflectionGetFieldValueAsTokenString(t *testing.T) {
tst.AssertEqual(t, gfvats(d, "ptr"), "4")
tst.AssertEqual(t, gfvats(d, "ptr2"), "")
tst.AssertEqual(t, gfvats(d, "fff"), "22.5")
tst.AssertEqual(t, gfvats(d, "cdate"), t0.Format(time.RFC3339Nano))
tst.AssertEqual(t, gfvats(d, "mdate"), t0.Format(time.RFC3339Nano))
}