Compare commits
11 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
abc8af525a
|
|||
|
19d943361b
|
|||
|
b464afae01
|
|||
|
56bc5e8285
|
|||
|
cb95bb561c
|
|||
| dff8941bd3 | |||
|
78e1c33e30
|
|||
|
d2f2a0558a
|
|||
|
fc4bed4b9f
|
|||
|
94a7bf250d | ||
|
f6121a6961
|
@@ -1,14 +1,15 @@
|
||||
package cursortoken
|
||||
|
||||
import (
|
||||
"context"
|
||||
"go.mongodb.org/mongo-driver/mongo"
|
||||
)
|
||||
|
||||
type RawFilter interface {
|
||||
FilterQuery() mongo.Pipeline
|
||||
FilterQuery(ctx context.Context) mongo.Pipeline
|
||||
}
|
||||
|
||||
type Filter interface {
|
||||
FilterQuery() mongo.Pipeline
|
||||
Pagination() (string, SortDirection, string, SortDirection)
|
||||
FilterQuery(ctx context.Context) mongo.Pipeline
|
||||
Pagination(ctx context.Context) (string, SortDirection, string, SortDirection)
|
||||
}
|
||||
|
||||
@@ -55,18 +55,6 @@ import (
|
||||
// => Wrap/New + Fatal
|
||||
//
|
||||
|
||||
var stackSkipLogger zerolog.Logger
|
||||
|
||||
func init() {
|
||||
cw := zerolog.ConsoleWriter{
|
||||
Out: os.Stdout,
|
||||
TimeFormat: "2006-01-02 15:04:05 Z07:00",
|
||||
}
|
||||
|
||||
multi := zerolog.MultiLevelWriter(cw)
|
||||
stackSkipLogger = zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(4).Logger()
|
||||
}
|
||||
|
||||
type Builder struct {
|
||||
wrappedErr error
|
||||
errorData *ExErr
|
||||
@@ -435,9 +423,9 @@ func (b *Builder) Build(ctxs ...context.Context) error {
|
||||
}
|
||||
|
||||
if pkgconfig.ZeroLogErrTraces && !b.noLog && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
|
||||
b.errorData.ShortLog(stackSkipLogger.Error())
|
||||
b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
|
||||
} else if pkgconfig.ZeroLogAllTraces && !b.noLog {
|
||||
b.errorData.ShortLog(stackSkipLogger.Error())
|
||||
b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
|
||||
}
|
||||
|
||||
b.errorData.CallListener(MethodBuild)
|
||||
@@ -459,9 +447,9 @@ func (b *Builder) Output(ctx context.Context, g *gin.Context) {
|
||||
b.errorData.Output(g)
|
||||
|
||||
if (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) && (pkgconfig.ZeroLogErrGinOutput || pkgconfig.ZeroLogAllGinOutput) {
|
||||
b.errorData.Log(stackSkipLogger.Error())
|
||||
b.errorData.Log(pkgconfig.ZeroLogger.Error())
|
||||
} else if (b.errorData.Severity == SevWarn) && (pkgconfig.ZeroLogAllGinOutput) {
|
||||
b.errorData.Log(stackSkipLogger.Warn())
|
||||
b.errorData.Log(pkgconfig.ZeroLogger.Warn())
|
||||
}
|
||||
|
||||
b.errorData.CallListener(MethodOutput)
|
||||
@@ -477,9 +465,9 @@ func (b *Builder) Print(ctxs ...context.Context) {
|
||||
}
|
||||
|
||||
if b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal {
|
||||
b.errorData.Log(stackSkipLogger.Error())
|
||||
b.errorData.Log(pkgconfig.ZeroLogger.Error())
|
||||
} else if b.errorData.Severity == SevWarn {
|
||||
b.errorData.ShortLog(stackSkipLogger.Warn())
|
||||
b.errorData.ShortLog(pkgconfig.ZeroLogger.Warn())
|
||||
}
|
||||
|
||||
b.errorData.CallListener(MethodPrint)
|
||||
@@ -499,7 +487,7 @@ func (b *Builder) Fatal(ctxs ...context.Context) {
|
||||
b.CtxData(MethodFatal, dctx)
|
||||
}
|
||||
|
||||
b.errorData.Log(stackSkipLogger.WithLevel(zerolog.FatalLevel))
|
||||
b.errorData.Log(pkgconfig.ZeroLogger.WithLevel(zerolog.FatalLevel))
|
||||
|
||||
b.errorData.CallListener(MethodFatal)
|
||||
|
||||
|
||||
@@ -4,8 +4,10 @@ import (
|
||||
"context"
|
||||
"fmt"
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/rs/zerolog"
|
||||
"gogs.mikescher.com/BlackForestBytes/goext/langext"
|
||||
"net/http"
|
||||
"os"
|
||||
)
|
||||
|
||||
type ErrorPackageConfig struct {
|
||||
@@ -21,6 +23,7 @@ type ErrorPackageConfig struct {
|
||||
ZeroLogAllGinOutput bool // autom print zerolog logs on ginext.Error() / .Output(gin) (for all Severities)
|
||||
ExtendGinMeta func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request) // (Optionally) extend the final error meta values with additional data from the gin context (a few are automatically added, here more can be included)
|
||||
ExtendContextMeta func(b *Builder, method Method, dctx context.Context) // (Optionally) extend the final error meta values with additional data from the context (a few are automatically added, here more can be included)
|
||||
ZeroLogger zerolog.Logger // The logger used to print exerr log messages
|
||||
}
|
||||
|
||||
type ErrorPackageConfigInit struct {
|
||||
@@ -36,6 +39,7 @@ type ErrorPackageConfigInit struct {
|
||||
ZeroLogAllGinOutput *bool
|
||||
ExtendGinMeta func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request)
|
||||
ExtendContextMeta func(b *Builder, method Method, dctx context.Context)
|
||||
ZeroLogger *zerolog.Logger
|
||||
}
|
||||
|
||||
var initialized = false
|
||||
@@ -81,6 +85,13 @@ func Init(cfg ErrorPackageConfigInit) {
|
||||
egcm = cfg.ExtendContextMeta
|
||||
}
|
||||
|
||||
var logger zerolog.Logger
|
||||
if cfg.ZeroLogger != nil {
|
||||
logger = *cfg.ZeroLogger
|
||||
} else {
|
||||
logger = newDefaultLogger()
|
||||
}
|
||||
|
||||
pkgconfig = ErrorPackageConfig{
|
||||
ZeroLogErrTraces: langext.Coalesce(cfg.ZeroLogErrTraces, pkgconfig.ZeroLogErrTraces),
|
||||
ZeroLogAllTraces: langext.Coalesce(cfg.ZeroLogAllTraces, pkgconfig.ZeroLogAllTraces),
|
||||
@@ -94,11 +105,23 @@ func Init(cfg ErrorPackageConfigInit) {
|
||||
ZeroLogErrGinOutput: langext.Coalesce(cfg.ZeroLogErrGinOutput, pkgconfig.ZeroLogErrGinOutput),
|
||||
ExtendGinMeta: egm,
|
||||
ExtendContextMeta: egcm,
|
||||
ZeroLogger: logger,
|
||||
}
|
||||
|
||||
initialized = true
|
||||
}
|
||||
|
||||
func newDefaultLogger() zerolog.Logger {
|
||||
cw := zerolog.ConsoleWriter{
|
||||
Out: os.Stdout,
|
||||
TimeFormat: "2006-01-02 15:04:05 Z07:00",
|
||||
}
|
||||
|
||||
multi := zerolog.MultiLevelWriter(cw)
|
||||
|
||||
return zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(4).Logger()
|
||||
}
|
||||
|
||||
func Initialized() bool {
|
||||
return initialized
|
||||
}
|
||||
|
||||
@@ -51,6 +51,20 @@ type Options struct {
|
||||
|
||||
// NewEngine creates a new (wrapped) ginEngine
|
||||
func NewEngine(opt Options) *GinWrapper {
|
||||
ginDebug := langext.Coalesce(opt.GinDebug, true)
|
||||
if ginDebug {
|
||||
gin.SetMode(gin.DebugMode)
|
||||
|
||||
// do not debug-print routes
|
||||
gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
|
||||
|
||||
} else {
|
||||
gin.SetMode(gin.ReleaseMode)
|
||||
|
||||
// do not debug-print routes
|
||||
gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
|
||||
}
|
||||
|
||||
engine := gin.New()
|
||||
|
||||
wrapper := &GinWrapper{
|
||||
@@ -58,7 +72,7 @@ func NewEngine(opt Options) *GinWrapper {
|
||||
opt: opt,
|
||||
suppressGinLogs: langext.Coalesce(opt.SuppressGinLogs, false),
|
||||
allowCors: langext.Coalesce(opt.AllowCors, false),
|
||||
ginDebug: langext.Coalesce(opt.GinDebug, true),
|
||||
ginDebug: ginDebug,
|
||||
bufferBody: langext.Coalesce(opt.BufferBody, false),
|
||||
requestTimeout: langext.Coalesce(opt.Timeout, 24*time.Hour),
|
||||
listenerBeforeRequest: opt.ListenerBeforeRequest,
|
||||
@@ -72,24 +86,10 @@ func NewEngine(opt Options) *GinWrapper {
|
||||
engine.Use(CorsMiddleware())
|
||||
}
|
||||
|
||||
if wrapper.ginDebug {
|
||||
gin.SetMode(gin.DebugMode)
|
||||
|
||||
// do not debug-print routes
|
||||
gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
|
||||
|
||||
if !wrapper.suppressGinLogs {
|
||||
ginlogger := gin.Logger()
|
||||
engine.Use(func(context *gin.Context) { ginlogger(context) })
|
||||
}
|
||||
|
||||
} else {
|
||||
gin.SetMode(gin.ReleaseMode)
|
||||
|
||||
// do not debug-print routes
|
||||
gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
|
||||
if ginDebug && !wrapper.suppressGinLogs {
|
||||
ginlogger := gin.Logger()
|
||||
engine.Use(func(context *gin.Context) { ginlogger(context) })
|
||||
}
|
||||
|
||||
return wrapper
|
||||
}
|
||||
|
||||
@@ -218,3 +218,7 @@ func (w *GinWrapper) ServeHTTP(req *http.Request) *httptest.ResponseRecorder {
|
||||
func (w *GinWrapper) ForwardRequest(writer http.ResponseWriter, req *http.Request) {
|
||||
w.engine.ServeHTTP(writer, req)
|
||||
}
|
||||
|
||||
func (w *GinWrapper) ListRoutes() []gin.RouteInfo {
|
||||
return w.engine.Routes()
|
||||
}
|
||||
|
||||
10
go.mod
10
go.mod
@@ -8,7 +8,7 @@ require (
|
||||
github.com/jmoiron/sqlx v1.4.0
|
||||
github.com/rs/xid v1.5.0
|
||||
github.com/rs/zerolog v1.33.0
|
||||
go.mongodb.org/mongo-driver v1.15.0
|
||||
go.mongodb.org/mongo-driver v1.16.0
|
||||
golang.org/x/crypto v0.24.0
|
||||
golang.org/x/sys v0.21.0
|
||||
golang.org/x/term v0.21.0
|
||||
@@ -21,7 +21,7 @@ require (
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/bytedance/sonic v1.11.8 // indirect
|
||||
github.com/bytedance/sonic v1.11.9 // indirect
|
||||
github.com/bytedance/sonic/loader v0.1.1 // indirect
|
||||
github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
|
||||
github.com/chenzhuoyu/iasm v0.9.1 // indirect
|
||||
@@ -32,12 +32,12 @@ require (
|
||||
github.com/gin-contrib/sse v0.1.0 // indirect
|
||||
github.com/go-playground/locales v0.14.1 // indirect
|
||||
github.com/go-playground/universal-translator v0.18.1 // indirect
|
||||
github.com/go-playground/validator/v10 v10.21.0 // indirect
|
||||
github.com/go-playground/validator/v10 v10.22.0 // indirect
|
||||
github.com/goccy/go-json v0.10.3 // indirect
|
||||
github.com/golang/snappy v0.0.4 // indirect
|
||||
github.com/google/uuid v1.5.0 // indirect
|
||||
github.com/json-iterator/go v1.1.12 // indirect
|
||||
github.com/klauspost/compress v1.17.8 // indirect
|
||||
github.com/klauspost/compress v1.17.9 // indirect
|
||||
github.com/klauspost/cpuid/v2 v2.2.8 // indirect
|
||||
github.com/leodido/go-urn v1.4.0 // indirect
|
||||
github.com/mattn/go-colorable v0.1.13 // indirect
|
||||
@@ -54,7 +54,7 @@ require (
|
||||
github.com/xdg-go/stringprep v1.0.4 // indirect
|
||||
github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 // indirect
|
||||
golang.org/x/arch v0.8.0 // indirect
|
||||
golang.org/x/image v0.17.0 // indirect
|
||||
golang.org/x/image v0.18.0 // indirect
|
||||
golang.org/x/net v0.26.0 // indirect
|
||||
golang.org/x/text v0.16.0 // indirect
|
||||
google.golang.org/protobuf v1.34.2 // indirect
|
||||
|
||||
12
go.sum
12
go.sum
@@ -22,6 +22,8 @@ github.com/bytedance/sonic v1.11.7 h1:k/l9p1hZpNIMJSk37wL9ltkcpqLfIho1vYthi4xT2t
|
||||
github.com/bytedance/sonic v1.11.7/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
|
||||
github.com/bytedance/sonic v1.11.8 h1:Zw/j1KfiS+OYTi9lyB3bb0CFxPJVkM17k1wyDG32LRA=
|
||||
github.com/bytedance/sonic v1.11.8/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
|
||||
github.com/bytedance/sonic v1.11.9 h1:LFHENlIY/SLzDWverzdOvgMztTxcfcF+cqNsz9pK5zg=
|
||||
github.com/bytedance/sonic v1.11.9/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
|
||||
github.com/bytedance/sonic/loader v0.1.0/go.mod h1:UmRT+IRTGKz/DAkzcEGzyVqQFJ7H9BqwBO3pm9H/+HY=
|
||||
github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
|
||||
github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
|
||||
@@ -81,6 +83,8 @@ github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBEx
|
||||
github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
|
||||
github.com/go-playground/validator/v10 v10.21.0 h1:4fZA11ovvtkdgaeev9RGWPgc1uj3H8W+rNYyH/ySBb0=
|
||||
github.com/go-playground/validator/v10 v10.21.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
|
||||
github.com/go-playground/validator/v10 v10.22.0 h1:k6HsTZ0sTnROkhS//R0O+55JgM8C4Bx7ia+JlgcnOao=
|
||||
github.com/go-playground/validator/v10 v10.22.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
|
||||
github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
|
||||
github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
|
||||
github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
|
||||
@@ -120,6 +124,8 @@ github.com/klauspost/compress v1.17.7 h1:ehO88t2UGzQK66LMdE8tibEd1ErmzZjNEqWkjLA
|
||||
github.com/klauspost/compress v1.17.7/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
|
||||
github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU=
|
||||
github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
|
||||
github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
|
||||
github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
|
||||
github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
|
||||
github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc=
|
||||
github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
|
||||
@@ -214,6 +220,10 @@ go.mongodb.org/mongo-driver v1.14.0 h1:P98w8egYRjYe3XDjxhYJagTokP/H6HzlsnojRgZRd
|
||||
go.mongodb.org/mongo-driver v1.14.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
|
||||
go.mongodb.org/mongo-driver v1.15.0 h1:rJCKC8eEliewXjZGf0ddURtl7tTVy1TK3bfl0gkUSLc=
|
||||
go.mongodb.org/mongo-driver v1.15.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
|
||||
go.mongodb.org/mongo-driver v1.15.1 h1:l+RvoUOoMXFmADTLfYDm7On9dRm7p4T80/lEQM+r7HU=
|
||||
go.mongodb.org/mongo-driver v1.15.1/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
|
||||
go.mongodb.org/mongo-driver v1.16.0 h1:tpRsfBJMROVHKpdGyc1BBEzzjDUWjItxbVSZ8Ls4BQ4=
|
||||
go.mongodb.org/mongo-driver v1.16.0/go.mod h1:oB6AhJQvFQL4LEHyXi6aJzQJtBiTQHiAd83l0GdFaiw=
|
||||
golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
|
||||
golang.org/x/arch v0.7.0 h1:pskyeJh/3AmoQ8CPE95vxHLqp1G1GfGNXTmcl9NEKTc=
|
||||
golang.org/x/arch v0.7.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
|
||||
@@ -246,6 +256,8 @@ golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
|
||||
golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
|
||||
golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
|
||||
golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
|
||||
golang.org/x/image v0.18.0 h1:jGzIakQa/ZXI1I0Fxvaa9W7yP25TqT6cHIHn+6CqvSQ=
|
||||
golang.org/x/image v0.18.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
|
||||
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
|
||||
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
|
||||
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
package goext
|
||||
|
||||
const GoextVersion = "0.0.470"
|
||||
const GoextVersion = "0.0.481"
|
||||
|
||||
const GoextVersionTimestamp = "2024-06-11T19:34:48+0200"
|
||||
const GoextVersionTimestamp = "2024-07-04T16:24:49+0200"
|
||||
|
||||
@@ -769,13 +769,6 @@ type structFields struct {
|
||||
}
|
||||
|
||||
func (se structEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
|
||||
|
||||
if v.CanAddr() && v.Addr().Type().Implements(goextJsonMarshallerType) {
|
||||
if gejm, ok := v.Addr().Interface().(GoextJsonMarshaller); ok {
|
||||
gejm.PreGoJsonMarshal()
|
||||
}
|
||||
}
|
||||
|
||||
next := byte('{')
|
||||
FieldLoop:
|
||||
for i := range se.fields.list {
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
package json
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
)
|
||||
|
||||
type GoextJsonMarshaller interface {
|
||||
PreGoJsonMarshal()
|
||||
}
|
||||
|
||||
var (
|
||||
goextJsonMarshallerType = reflect.TypeOf((*GoextJsonMarshaller)(nil)).Elem()
|
||||
)
|
||||
@@ -1,37 +0,0 @@
|
||||
package json
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type testStruct1 struct {
|
||||
TS2 *testStruct2 `json:"ts2"`
|
||||
}
|
||||
|
||||
type testStruct2 struct {
|
||||
A string `json:"a"`
|
||||
}
|
||||
|
||||
func (t *testStruct2) PreGoJsonMarshal() {
|
||||
t.A = "Hello"
|
||||
}
|
||||
|
||||
func TestGoextJsonMarshaller(t *testing.T) {
|
||||
t1 := testStruct1{TS2: &testStruct2{}}
|
||||
|
||||
v, err := Marshal(t1)
|
||||
if err != nil {
|
||||
t.Fatal()
|
||||
}
|
||||
|
||||
fmt.Printf("%s\n", v)
|
||||
|
||||
if string(v) != `{"ts2":{"a":"Hello"}}` {
|
||||
t.Fatalf("PreGoJsonMarshal failed")
|
||||
}
|
||||
|
||||
if t1.TS2.A != "Hello" {
|
||||
t.Fatalf("PreGoJsonMarshal failed")
|
||||
}
|
||||
}
|
||||
@@ -564,3 +564,18 @@ func ArrChunk[T any](arr []T, chunkSize int) [][]T {
|
||||
|
||||
return res
|
||||
}
|
||||
|
||||
func ArrGroupBy[T1 any, T2 comparable](arr []T1, groupfunc func(v T1) T2) map[T2][]T1 {
|
||||
r := make(map[T2][]T1)
|
||||
|
||||
for _, v := range arr {
|
||||
key := groupfunc(v)
|
||||
if _, ok := r[key]; ok {
|
||||
r[key] = append(r[key], v)
|
||||
} else {
|
||||
r[key] = []T1{v}
|
||||
}
|
||||
}
|
||||
|
||||
return r
|
||||
}
|
||||
|
||||
@@ -88,12 +88,15 @@ func StrRunePadRight(str string, pad string, padlen int) string {
|
||||
|
||||
func Indent(str string, pad string) string {
|
||||
eonl := strings.HasSuffix(str, "\n")
|
||||
if eonl {
|
||||
str = str[0 : len(str)-1]
|
||||
}
|
||||
r := ""
|
||||
for _, v := range strings.Split(str, "\n") {
|
||||
r += pad + v + "\n"
|
||||
}
|
||||
|
||||
if eonl {
|
||||
if !eonl {
|
||||
r = r[0 : len(r)-1]
|
||||
}
|
||||
|
||||
@@ -115,3 +118,21 @@ func StrRepeat(val string, count int) string {
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
func StrWrap(val string, linelen int, seperator string) string {
|
||||
res := ""
|
||||
|
||||
for iPos := 0; ; {
|
||||
next := min(iPos+linelen, len(val))
|
||||
res += val[iPos:next]
|
||||
|
||||
iPos = next
|
||||
if iPos >= len(val) {
|
||||
break
|
||||
}
|
||||
|
||||
res += seperator
|
||||
}
|
||||
|
||||
return res
|
||||
}
|
||||
|
||||
152
langext/string_test.go
Normal file
152
langext/string_test.go
Normal file
@@ -0,0 +1,152 @@
|
||||
package langext
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestStrLimitBehaviour(t *testing.T) {
|
||||
val := "Hello, World!"
|
||||
maxlen := 5
|
||||
suffix := "..."
|
||||
expected := "He..."
|
||||
result := StrLimit(val, maxlen, suffix)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrSplitBehaviour1(t *testing.T) {
|
||||
val := "Hello,World,,"
|
||||
sep := ","
|
||||
expected := []string{"Hello", "World"}
|
||||
result := StrSplit(val, sep, false)
|
||||
if len(result) != len(expected) {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrSplitBehaviour2(t *testing.T) {
|
||||
val := "Hello,World,,"
|
||||
sep := ","
|
||||
expected := []string{"Hello", "World", "", ""}
|
||||
result := StrSplit(val, sep, true)
|
||||
if len(result) != len(expected) {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrPadRightBehaviour(t *testing.T) {
|
||||
str := "Hello"
|
||||
pad := "*"
|
||||
padlen := 10
|
||||
expected := "Hello*****"
|
||||
result := StrPadRight(str, pad, padlen)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrPadLeftBehaviour(t *testing.T) {
|
||||
str := "Hello"
|
||||
pad := "*"
|
||||
padlen := 10
|
||||
expected := "*****Hello"
|
||||
result := StrPadLeft(str, pad, padlen)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrRunePadLeftBehaviour(t *testing.T) {
|
||||
str := "Hello"
|
||||
pad := "*"
|
||||
padlen := 10
|
||||
expected := "*****Hello"
|
||||
result := StrRunePadLeft(str, pad, padlen)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrRunePadRightBehaviour(t *testing.T) {
|
||||
str := "Hello"
|
||||
pad := "*"
|
||||
padlen := 10
|
||||
expected := "Hello*****"
|
||||
result := StrRunePadRight(str, pad, padlen)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIndentBehaviour1(t *testing.T) {
|
||||
str := "Hello\nWorld"
|
||||
pad := ".."
|
||||
expected := "..Hello\n..World"
|
||||
result := Indent(str, pad)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIndentBehaviour2(t *testing.T) {
|
||||
str := "Hello\nWorld\n"
|
||||
pad := ".."
|
||||
expected := "..Hello\n..World\n"
|
||||
result := Indent(str, pad)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrRepeatBehaviour(t *testing.T) {
|
||||
val := "Hello"
|
||||
count := 3
|
||||
expected := "HelloHelloHello"
|
||||
result := StrRepeat(val, count)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrWrapBehaviour1(t *testing.T) {
|
||||
val := "123456789"
|
||||
linelen := 5
|
||||
seperator := "\n"
|
||||
expected := "12345\n6789"
|
||||
result := StrWrap(val, linelen, seperator)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrWrapBehaviour2(t *testing.T) {
|
||||
val := "1234567890"
|
||||
linelen := 5
|
||||
seperator := "\n"
|
||||
expected := "12345\n67890"
|
||||
result := StrWrap(val, linelen, seperator)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrWrapBehaviour3(t *testing.T) {
|
||||
val := "****************"
|
||||
linelen := 4
|
||||
seperator := "\n"
|
||||
expected := "****\n****\n****\n****"
|
||||
result := StrWrap(val, linelen, seperator)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrWrapBehaviour4(t *testing.T) {
|
||||
val := "*****************"
|
||||
linelen := 4
|
||||
seperator := "\n"
|
||||
expected := "****\n****\n****\n****\n*"
|
||||
result := StrWrap(val, linelen, seperator)
|
||||
if result != expected {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
@@ -1,13 +1,14 @@
|
||||
package pagination
|
||||
|
||||
import (
|
||||
"context"
|
||||
"go.mongodb.org/mongo-driver/bson"
|
||||
"go.mongodb.org/mongo-driver/mongo"
|
||||
)
|
||||
|
||||
type MongoFilter interface {
|
||||
FilterQuery() mongo.Pipeline
|
||||
Sort() bson.D
|
||||
FilterQuery(ctx context.Context) mongo.Pipeline
|
||||
Sort(ctx context.Context) bson.D
|
||||
}
|
||||
|
||||
type dynamicFilter struct {
|
||||
@@ -15,11 +16,11 @@ type dynamicFilter struct {
|
||||
sort bson.D
|
||||
}
|
||||
|
||||
func (d dynamicFilter) FilterQuery() mongo.Pipeline {
|
||||
func (d dynamicFilter) FilterQuery(ctx context.Context) mongo.Pipeline {
|
||||
return d.pipeline
|
||||
}
|
||||
|
||||
func (d dynamicFilter) Sort() bson.D {
|
||||
func (d dynamicFilter) Sort(ctx context.Context) bson.D {
|
||||
return d.sort
|
||||
}
|
||||
|
||||
|
||||
185
reflectext/structAccess.go
Normal file
185
reflectext/structAccess.go
Normal file
@@ -0,0 +1,185 @@
|
||||
package reflectext
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"gogs.mikescher.com/BlackForestBytes/goext/langext"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var ErrAccessStructInvalidFieldType = errors.New("invalid field type")
|
||||
var ErrAccessStructFieldInPathWasNil = errors.New("a field in the path was nil")
|
||||
var ErrAccessStructInvalidArrayIndex = errors.New("invalid array index")
|
||||
var ErrAccessStructInvalidMapKey = errors.New("invalid map key")
|
||||
var ErrAccessStructArrayAccess = errors.New("trying to access array")
|
||||
var ErrAccessStructMapAccess = errors.New("trying to access map")
|
||||
var ErrAccessStructMissingField = errors.New("missing field")
|
||||
|
||||
type AccessStructOpt struct {
|
||||
ReturnNilOnMissingFields bool // return nil (instead of error) when a field in the path is missing (aka the supplied path is wrong)
|
||||
ReturnNilOnNilPtrFields bool // return nil (instead of error) when a field in the path is nil
|
||||
ReturnNilOnWrongFinalFieldType bool // return nil (instead of error) when the (final) field is not of the requested generic type
|
||||
ReturnNilOnWrongIntermedFieldType bool // return nil (instead of error) when the intermediate field has an invalid type
|
||||
ReturnNilOnInvalidArrayIndizes bool // return nil (instead of error) when trying to acces an array with an invalid index (not a number or out of range)
|
||||
ReturnNilOnMissingMapKeys bool // return nil (instead of error) when trying to access a map with a missing key
|
||||
UsedTagForKeys *string // Use this tag for key names in the struct (instead of the StructField.Name)
|
||||
PreventArrayAccess bool // do not access array indizes - throw an error instead
|
||||
PreventMapAccess bool // do not access maps - throw an error instead
|
||||
}
|
||||
|
||||
func AccessJSONStruct[TResult any](v any, path string) (TResult, error) {
|
||||
return AccessStructByStringPath[TResult](v, path, AccessStructOpt{UsedTagForKeys: langext.Ptr("json")})
|
||||
}
|
||||
|
||||
func AccessStruct[TResult any](v any, path string) (TResult, error) {
|
||||
return AccessStructByStringPath[TResult](v, path, AccessStructOpt{})
|
||||
}
|
||||
|
||||
func AccessStructByArrayPath[TResult any](v any, path []string, opts ...AccessStructOpt) (TResult, error) {
|
||||
opt := AccessStructOpt{}
|
||||
if len(opts) > 0 {
|
||||
opt = opts[0]
|
||||
}
|
||||
|
||||
resultVal, err := accessStructByPath(reflect.ValueOf(v), path, opt)
|
||||
if err != nil {
|
||||
return *new(TResult), err
|
||||
}
|
||||
|
||||
if resultValCast, ok := resultVal.(TResult); ok {
|
||||
return resultValCast, nil
|
||||
} else if opt.ReturnNilOnWrongFinalFieldType {
|
||||
return *new(TResult), nil
|
||||
} else {
|
||||
return *new(TResult), ErrAccessStructInvalidFieldType
|
||||
}
|
||||
}
|
||||
|
||||
func AccessStructByStringPath[TResult any](v any, path string, opts ...AccessStructOpt) (TResult, error) {
|
||||
opt := AccessStructOpt{}
|
||||
if len(opts) > 0 {
|
||||
opt = opts[0]
|
||||
}
|
||||
arrpath := strings.Split(path, ".")
|
||||
|
||||
resultVal, err := accessStructByPath(reflect.ValueOf(v), arrpath, opt)
|
||||
if err != nil {
|
||||
return *new(TResult), err
|
||||
}
|
||||
|
||||
if resultValCast, ok := resultVal.(TResult); ok {
|
||||
return resultValCast, nil
|
||||
} else if opt.ReturnNilOnWrongFinalFieldType {
|
||||
return *new(TResult), nil
|
||||
} else {
|
||||
return *new(TResult), ErrAccessStructInvalidFieldType
|
||||
}
|
||||
}
|
||||
|
||||
func accessStructByPath(val reflect.Value, path []string, opt AccessStructOpt) (any, error) {
|
||||
if len(path) == 0 {
|
||||
return val.Interface(), nil
|
||||
}
|
||||
|
||||
currPath := path[0]
|
||||
|
||||
if val.Kind() == reflect.Ptr {
|
||||
if val.IsNil() {
|
||||
if opt.ReturnNilOnNilPtrFields {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructFieldInPathWasNil
|
||||
}
|
||||
}
|
||||
return accessStructByPath(val.Elem(), path, opt)
|
||||
}
|
||||
|
||||
if val.Kind() == reflect.Array || val.Kind() == reflect.Slice {
|
||||
if opt.PreventArrayAccess {
|
||||
return nil, ErrAccessStructArrayAccess
|
||||
}
|
||||
|
||||
if val.IsNil() {
|
||||
if opt.ReturnNilOnNilPtrFields {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructFieldInPathWasNil
|
||||
}
|
||||
}
|
||||
|
||||
arrIdx, err := strconv.ParseInt(currPath, 10, 64)
|
||||
if err != nil {
|
||||
if opt.ReturnNilOnInvalidArrayIndizes {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructInvalidArrayIndex
|
||||
}
|
||||
}
|
||||
if arrIdx < 0 || int(arrIdx) >= val.Len() {
|
||||
if opt.ReturnNilOnInvalidArrayIndizes {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructInvalidArrayIndex
|
||||
}
|
||||
}
|
||||
return accessStructByPath(val.Index(int(arrIdx)), path[1:], opt)
|
||||
}
|
||||
|
||||
if val.Kind() == reflect.Map {
|
||||
if opt.PreventMapAccess {
|
||||
return nil, ErrAccessStructMapAccess
|
||||
}
|
||||
|
||||
if val.IsNil() {
|
||||
if opt.ReturnNilOnNilPtrFields {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructFieldInPathWasNil
|
||||
}
|
||||
}
|
||||
|
||||
mapval := val.MapIndex(reflect.ValueOf(currPath))
|
||||
if !mapval.IsValid() || mapval.IsZero() {
|
||||
if opt.ReturnNilOnMissingMapKeys {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructInvalidMapKey
|
||||
}
|
||||
}
|
||||
|
||||
return accessStructByPath(mapval, path[1:], opt)
|
||||
}
|
||||
|
||||
if val.Kind() == reflect.Struct {
|
||||
if opt.UsedTagForKeys != nil {
|
||||
for i := 0; i < val.NumField(); i++ {
|
||||
if val.Type().Field(i).Tag.Get(*opt.UsedTagForKeys) == currPath {
|
||||
return accessStructByPath(val.Field(i), path[1:], opt)
|
||||
}
|
||||
}
|
||||
if opt.ReturnNilOnMissingFields {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructMissingField
|
||||
}
|
||||
} else {
|
||||
for i := 0; i < val.NumField(); i++ {
|
||||
if val.Type().Field(i).Name == currPath {
|
||||
return accessStructByPath(val.Field(i), path[1:], opt)
|
||||
}
|
||||
}
|
||||
if opt.ReturnNilOnMissingFields {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructMissingField
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if opt.ReturnNilOnWrongIntermedFieldType {
|
||||
return nil, nil
|
||||
} else {
|
||||
return nil, ErrAccessStructMissingField
|
||||
}
|
||||
}
|
||||
259
reflectext/structAccess_test.go
Normal file
259
reflectext/structAccess_test.go
Normal file
@@ -0,0 +1,259 @@
|
||||
package reflectext
|
||||
|
||||
import "testing"
|
||||
|
||||
type TestStruct struct {
|
||||
Name string `json:"name"`
|
||||
Age int `json:"age"`
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_HappyPath(t *testing.T) {
|
||||
testStruct := TestStruct{Name: "John", Age: 30}
|
||||
result, err := AccessStructByArrayPath[string](testStruct, []string{"Name"})
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "John" {
|
||||
t.Errorf("Expected 'John', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_InvalidField(t *testing.T) {
|
||||
testStruct := TestStruct{Name: "John", Age: 30}
|
||||
_, err := AccessStructByArrayPath[string](testStruct, []string{"Invalid"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByStringPath_HappyPath(t *testing.T) {
|
||||
testStruct := TestStruct{Name: "John", Age: 30}
|
||||
result, err := AccessStructByStringPath[string](testStruct, "Name")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "John" {
|
||||
t.Errorf("Expected 'John', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByStringPath_InvalidField(t *testing.T) {
|
||||
testStruct := TestStruct{Name: "John", Age: 30}
|
||||
_, err := AccessStructByStringPath[string](testStruct, "Invalid")
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
type RecursiveStruct struct {
|
||||
Name string
|
||||
Sub *RecursiveStruct
|
||||
SubSlice []RecursiveStruct
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_RecursiveStruct(t *testing.T) {
|
||||
testStruct := RecursiveStruct{Name: "John", Sub: &RecursiveStruct{Name: "Jane"}}
|
||||
result, err := AccessStructByArrayPath[string](*testStruct.Sub, []string{"Name"})
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "Jane" {
|
||||
t.Errorf("Expected 'Jane', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_RecursiveStructSlice(t *testing.T) {
|
||||
testStruct := RecursiveStruct{Name: "John", SubSlice: []RecursiveStruct{{Name: "Jane"}}}
|
||||
result, err := AccessStructByArrayPath[string](testStruct.SubSlice[0], []string{"Name"})
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "Jane" {
|
||||
t.Errorf("Expected 'Jane', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_WrongType(t *testing.T) {
|
||||
testStruct := TestStruct{Name: "John", Age: 30}
|
||||
_, err := AccessStructByArrayPath[int](testStruct, []string{"Name"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_InvalidPath(t *testing.T) {
|
||||
testStruct := TestStruct{Name: "John", Age: 30}
|
||||
_, err := AccessStructByArrayPath[string](testStruct, []string{"Name", "Invalid"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
type NestedStruct struct {
|
||||
Name string
|
||||
Sub *TestStruct
|
||||
}
|
||||
|
||||
func TestAccessStructByStringPath_NestedStruct(t *testing.T) {
|
||||
testStruct := NestedStruct{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
|
||||
result, err := AccessStructByStringPath[string](testStruct, "Sub.Name")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "Jane" {
|
||||
t.Errorf("Expected 'Jane', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
type DeepNestedStruct struct {
|
||||
Name string
|
||||
Sub *NestedStruct
|
||||
}
|
||||
|
||||
func TestAccessStructByStringPath_DeepNestedStruct(t *testing.T) {
|
||||
testStruct := DeepNestedStruct{Name: "John", Sub: &NestedStruct{Name: "Jane", Sub: &TestStruct{Name: "Doe", Age: 30}}}
|
||||
result, err := AccessStructByStringPath[string](testStruct, "Sub.Sub.Name")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "Doe" {
|
||||
t.Errorf("Expected 'Doe', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
type MapStruct struct {
|
||||
Name string
|
||||
Age int
|
||||
}
|
||||
|
||||
type TestStructWithMap struct {
|
||||
MapField map[string]MapStruct
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_MapField(t *testing.T) {
|
||||
testStruct := TestStructWithMap{
|
||||
MapField: map[string]MapStruct{
|
||||
"key": {Name: "John", Age: 30},
|
||||
},
|
||||
}
|
||||
result, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "key", "Name"})
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "John" {
|
||||
t.Errorf("Expected 'John', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_InvalidMapKey(t *testing.T) {
|
||||
testStruct := TestStructWithMap{
|
||||
MapField: map[string]MapStruct{
|
||||
"key": {Name: "John", Age: 30},
|
||||
},
|
||||
}
|
||||
_, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "invalid", "Name"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
type ArrayStruct struct {
|
||||
Name string
|
||||
Arr []TestStruct
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_ArrayField(t *testing.T) {
|
||||
testStruct := ArrayStruct{
|
||||
Name: "John",
|
||||
Arr: []TestStruct{{Name: "Jane", Age: 30}},
|
||||
}
|
||||
result, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "0", "Name"})
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "Jane" {
|
||||
t.Errorf("Expected 'Jane', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_InvalidArrayIndex(t *testing.T) {
|
||||
testStruct := ArrayStruct{
|
||||
Name: "John",
|
||||
Arr: []TestStruct{{Name: "Jane", Age: 30}},
|
||||
}
|
||||
_, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "1", "Name"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
type FunctionStruct struct {
|
||||
Name string
|
||||
Func func() string
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_FunctionField(t *testing.T) {
|
||||
testStruct := FunctionStruct{Name: "John", Func: func() string { return "Hello" }}
|
||||
_, err := AccessStructByArrayPath[string](testStruct, []string{"Func"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_NonExistentPath(t *testing.T) {
|
||||
testStruct := TestStruct{Name: "John", Age: 30}
|
||||
_, err := AccessStructByArrayPath[string](testStruct, []string{"NonExistent"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
type NestedStructWithTag struct {
|
||||
Name string `json:"name"`
|
||||
Sub *TestStruct `json:"sub"`
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_UsedTagForKeys(t *testing.T) {
|
||||
testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
|
||||
tag := "json"
|
||||
result, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "name"}, AccessStructOpt{UsedTagForKeys: &tag})
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != "Jane" {
|
||||
t.Errorf("Expected 'Jane', got '%s'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_UsedTagForKeysInvalid(t *testing.T) {
|
||||
testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
|
||||
tag := "json"
|
||||
_, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "invalid"}, AccessStructOpt{UsedTagForKeys: &tag})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
type DifferentTypeStruct struct {
|
||||
Name string
|
||||
Age int
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_DifferentType(t *testing.T) {
|
||||
testStruct := DifferentTypeStruct{Name: "John", Age: 30}
|
||||
result, err := AccessStructByArrayPath[any](testStruct, []string{"Age"})
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if result != 30 {
|
||||
t.Errorf("Expected '30', got '%v'", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccessStructByArrayPath_DifferentTypeInvalid(t *testing.T) {
|
||||
testStruct := DifferentTypeStruct{Name: "John", Age: 30}
|
||||
_, err := AccessStructByArrayPath[any](testStruct, []string{"Invalid"})
|
||||
if err == nil {
|
||||
t.Errorf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
13
timeext/diff.go
Normal file
13
timeext/diff.go
Normal file
@@ -0,0 +1,13 @@
|
||||
package timeext
|
||||
|
||||
import "time"
|
||||
|
||||
func YearDifference(t1 time.Time, t2 time.Time, tz *time.Location) float64 {
|
||||
|
||||
yDelta := float64(t1.Year() - t2.Year())
|
||||
|
||||
processT1 := float64(t1.Sub(TimeToYearStart(t1, tz))) / float64(TimeToYearEnd(t1, tz).Sub(TimeToYearStart(t1, tz)))
|
||||
processT2 := float64(t2.Sub(TimeToYearStart(t2, tz))) / float64(TimeToYearEnd(t2, tz).Sub(TimeToYearStart(t2, tz)))
|
||||
|
||||
return yDelta + (processT1 - processT2)
|
||||
}
|
||||
83
timeext/diff_test.go
Normal file
83
timeext/diff_test.go
Normal file
@@ -0,0 +1,83 @@
|
||||
package timeext
|
||||
|
||||
import (
|
||||
"math"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestYearDifferenceWithSameYearAndDay(t *testing.T) {
|
||||
t1 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
expected := 0.0
|
||||
result := YearDifference(t1, t2, time.UTC)
|
||||
if !epsilonEquals(result, expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestYearDifferenceWithOneYearApart(t *testing.T) {
|
||||
t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
expected := 1.0
|
||||
result := YearDifference(t1, t2, time.UTC)
|
||||
if !epsilonEquals(result, expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestYearDifferenceWithDifferentMonths(t *testing.T) {
|
||||
t1 := time.Date(2020, 6, 1, 0, 0, 0, 0, time.UTC)
|
||||
t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
expected := 0.4166666666666667 // Approximation of 5/12 months
|
||||
result := YearDifference(t1, t2, time.UTC)
|
||||
if !epsilonEquals(result, expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestYearDifferenceAcrossYears(t *testing.T) {
|
||||
t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
|
||||
t2 := time.Date(2020, 6, 1, 0, 0, 0, 0, time.UTC)
|
||||
expected := 0.5833333333333334 // Approximation of 7/12 months
|
||||
result := YearDifference(t1, t2, time.UTC)
|
||||
if !epsilonEquals(result, expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestYearDifferenceWithTimezone(t *testing.T) {
|
||||
tz, _ := time.LoadLocation("America/New_York")
|
||||
t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, tz)
|
||||
t2 := time.Date(2020, 6, 1, 0, 0, 0, 0, tz)
|
||||
expected := 0.5833333333333334 // Same as UTC but ensuring timezone is considered
|
||||
result := YearDifference(t1, t2, tz)
|
||||
if !epsilonEquals(result, expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestYearDifferenceWithNegativeDifference(t *testing.T) {
|
||||
t1 := time.Date(2020, 1, 1, 0, 0, 0, 0, TimezoneBerlin)
|
||||
t2 := time.Date(2021, 1, 1, 0, 0, 0, 0, TimezoneBerlin)
|
||||
expected := -1.0
|
||||
result := YearDifference(t1, t2, TimezoneBerlin)
|
||||
if !epsilonEquals(result, expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestYearDifferenceWithNegativeDifference2(t *testing.T) {
|
||||
t1 := time.Date(2020, 7, 1, 0, 0, 0, 0, TimezoneBerlin)
|
||||
t2 := time.Date(2021, 7, 1, 0, 0, 0, 0, TimezoneBerlin)
|
||||
expected := -1.0
|
||||
result := YearDifference(t1, t2, TimezoneBerlin)
|
||||
if !epsilonEquals(result, expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func epsilonEquals(a, b float64) bool {
|
||||
epsilon := 0.01
|
||||
return math.Abs(a-b) < epsilon
|
||||
}
|
||||
@@ -65,6 +65,10 @@ func TimeToYearEnd(t time.Time, tz *time.Location) time.Time {
|
||||
return TimeToYearStart(t, tz).AddDate(1, 0, 0).Add(-1)
|
||||
}
|
||||
|
||||
func TimeToNextYearStart(t time.Time, tz *time.Location) time.Time {
|
||||
return TimeToYearStart(t, tz).AddDate(1, 0, 0)
|
||||
}
|
||||
|
||||
// IsSameDayIncludingDateBoundaries returns true if t1 and t2 are part of the same day (TZ/Berlin), the boundaries of the day are
|
||||
// inclusive, this means 2021-09-15T00:00:00 is still part of the day 2021-09-14
|
||||
func IsSameDayIncludingDateBoundaries(t1 time.Time, t2 time.Time, tz *time.Location) bool {
|
||||
|
||||
@@ -72,6 +72,13 @@ func TestIsSunday(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsSunday_OnSunday(t *testing.T) {
|
||||
sunday := time.Date(2022, 5, 15, 0, 0, 0, 0, TimezoneBerlin) // A Sunday
|
||||
if !IsSunday(sunday, TimezoneBerlin) {
|
||||
t.Errorf("Expected true for Sunday")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDurationFromTime(t *testing.T) {
|
||||
expected := time.Duration(13*time.Hour + 14*time.Minute + 15*time.Second)
|
||||
result := DurationFromTime(13, 14, 15)
|
||||
@@ -156,3 +163,31 @@ func TestAddYears(t *testing.T) {
|
||||
t.Errorf("Expected %v but got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsDatePartEqual_SameDateDifferentTimes(t *testing.T) {
|
||||
tz := time.UTC
|
||||
t1 := time.Date(2022, 5, 18, 10, 30, 0, 0, tz)
|
||||
t2 := time.Date(2022, 5, 18, 20, 45, 0, 0, tz)
|
||||
if !IsDatePartEqual(t1, t2, tz) {
|
||||
t.Errorf("Expected dates to be equal")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWithTimePart_ChangeTime(t *testing.T) {
|
||||
base := time.Date(2022, 5, 18, 0, 0, 0, 0, time.UTC)
|
||||
result := WithTimePart(base, 15, 30, 45)
|
||||
expected := time.Date(2022, 5, 18, 15, 30, 45, 0, time.UTC)
|
||||
if !result.Equal(expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCombineDateAndTime_CombineDifferentParts(t *testing.T) {
|
||||
date := time.Date(2022, 5, 18, 0, 0, 0, 0, time.UTC)
|
||||
timePart := time.Date(2000, 1, 1, 15, 30, 45, 0, time.UTC)
|
||||
result := CombineDateAndTime(date, timePart)
|
||||
expected := time.Date(2022, 5, 18, 15, 30, 45, 0, time.UTC)
|
||||
if !result.Equal(expected) {
|
||||
t.Errorf("Expected %v, got %v", expected, result)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -19,6 +19,8 @@ func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, op
|
||||
return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
|
||||
}
|
||||
|
||||
defer func() { _ = cursor.Close(ctx) }()
|
||||
|
||||
res, err := c.decodeAll(ctx, cursor)
|
||||
if err != nil {
|
||||
return nil, exerr.Wrap(err, "failed to decode values").Build()
|
||||
@@ -38,6 +40,8 @@ func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeli
|
||||
return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
|
||||
}
|
||||
|
||||
defer func() { _ = cursor.Close(ctx) }()
|
||||
|
||||
if cursor.Next(ctx) {
|
||||
v, err := c.decodeSingle(ctx, cursor)
|
||||
if err != nil {
|
||||
@@ -60,6 +64,8 @@ func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline,
|
||||
return *new(TData), exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
|
||||
}
|
||||
|
||||
defer func() { _ = cursor.Close(ctx) }()
|
||||
|
||||
if cursor.Next(ctx) {
|
||||
v, err := c.decodeSingle(ctx, cursor)
|
||||
if err != nil {
|
||||
|
||||
@@ -64,6 +64,8 @@ func (c *Coll[TData]) Find(ctx context.Context, filter bson.M, opts ...*options.
|
||||
return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
|
||||
}
|
||||
|
||||
defer func() { _ = cursor.Close(ctx) }()
|
||||
|
||||
res, err := c.decodeAll(ctx, cursor)
|
||||
if err != nil {
|
||||
return nil, exerr.Wrap(err, "failed to decode values").Build()
|
||||
|
||||
@@ -80,6 +80,8 @@ func (c *Coll[TData]) findOneInternal(ctx context.Context, filter bson.M, allowN
|
||||
return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed").Any("pipeline", pipeline).Str("collection", c.Name()).NoLog().Build()
|
||||
}
|
||||
|
||||
defer func() { _ = cursor.Close(ctx) }()
|
||||
|
||||
if cursor.Next(ctx) {
|
||||
v, err := c.decodeSingle(ctx, cursor)
|
||||
if err != nil {
|
||||
|
||||
@@ -25,8 +25,8 @@ func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int,
|
||||
pd2 := ct.SortASC
|
||||
|
||||
if filter != nil {
|
||||
pipeline = filter.FilterQuery()
|
||||
pf1, pd1, pf2, pd2 = filter.Pagination()
|
||||
pipeline = filter.FilterQuery(ctx)
|
||||
pf1, pd1, pf2, pd2 = filter.Pagination(ctx)
|
||||
}
|
||||
|
||||
sortPrimary := pf1
|
||||
@@ -69,6 +69,8 @@ func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int,
|
||||
return nil, ct.CursorToken{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
|
||||
}
|
||||
|
||||
defer func() { _ = cursor.Close(ctx) }()
|
||||
|
||||
// fast branch
|
||||
if pageSize == nil {
|
||||
entries, err := c.decodeAll(ctx, cursor)
|
||||
@@ -109,7 +111,7 @@ func (c *Coll[TData]) Count(ctx context.Context, filter ct.RawFilter) (int64, er
|
||||
Count int64 `bson:"c"`
|
||||
}
|
||||
|
||||
pipeline := filter.FilterQuery()
|
||||
pipeline := filter.FilterQuery(ctx)
|
||||
|
||||
pipeline = append(pipeline, bson.D{{Key: "$count", Value: "c"}})
|
||||
|
||||
@@ -118,6 +120,8 @@ func (c *Coll[TData]) Count(ctx context.Context, filter ct.RawFilter) (int64, er
|
||||
return 0, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
|
||||
}
|
||||
|
||||
defer func() { _ = cursor.Close(ctx) }()
|
||||
|
||||
if cursor.Next(ctx) {
|
||||
v := countRes{}
|
||||
err = cursor.Decode(&v)
|
||||
@@ -152,7 +156,7 @@ func (c *Coll[TData]) ListAllIDs(ctx context.Context, filter ct.RawFilter) ([]st
|
||||
pipelineFilter := mongo.Pipeline{}
|
||||
|
||||
if filter != nil {
|
||||
pipelineFilter = filter.FilterQuery()
|
||||
pipelineFilter = filter.FilterQuery(ctx)
|
||||
}
|
||||
|
||||
extrModPipelineResolved := mongo.Pipeline{}
|
||||
|
||||
@@ -23,8 +23,8 @@ func (c *Coll[TData]) Paginate(ctx context.Context, filter pag.MongoFilter, page
|
||||
sort := bson.D{}
|
||||
|
||||
if filter != nil {
|
||||
pipelineFilter = filter.FilterQuery()
|
||||
sort = filter.Sort()
|
||||
pipelineFilter = filter.FilterQuery(ctx)
|
||||
sort = filter.Sort(ctx)
|
||||
}
|
||||
|
||||
if len(sort) != 0 {
|
||||
|
||||
Reference in New Issue
Block a user