[incubator-devlake] branch main updated: fix(zentao): fix type conversion when setting scopes (#6286)

[klesh]

This is an automated email from the ASF dual-hosted git repository.

klesh pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-devlake.git


The following commit(s) were added to refs/heads/main by this push:
     new 511088e82 fix(zentao): fix type conversion when setting scopes (#6286)
511088e82 is described below

commit 511088e82bb45cce7d0e01af3c52dc961d5cb477
Author: Lynwee <linwei....@merico.dev>
AuthorDate: Thu Oct 19 19:06:06 2023 +0800

    fix(zentao): fix type conversion when setting scopes (#6286)
    
    * fix(zentao): fix type conversion when setting scopes
    
    * refactor(zentao): rename defaultCustomDecoders to 
defaultCustomDecoderHooks
    
    * refactor(zentao): remove unused type field for StringFloat64
---
 backend/core/models/common/string_float64.go     | 20 +++++++-------------
 backend/helpers/pluginhelper/api/mapstructure.go | 15 +++++++++++++--
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/backend/core/models/common/string_float64.go 
b/backend/core/models/common/string_float64.go
index a6c9c7402..22ca4d53b 100644
--- a/backend/core/models/common/string_float64.go
+++ b/backend/core/models/common/string_float64.go
@@ -26,17 +26,19 @@ import (
 
 type StringFloat64 struct {
        v float64
-       t string
+}
+
+func NewStringFloat64FromAny(f interface{}) *StringFloat64 {
+       return &StringFloat64{
+               v: cast.ToFloat64(f),
+       }
 }
 
 func (f *StringFloat64) MarshalJSON() ([]byte, error) {
-       return json.Marshal(f.String())
+       return json.Marshal(f.v)
 }
 
 func (f *StringFloat64) String() string {
-       if f.t == "string" {
-               return fmt.Sprintf("\"%v\"", f.v)
-       }
        return fmt.Sprintf("%v", f.v)
 }
 
@@ -45,12 +47,6 @@ func (f *StringFloat64) UnmarshalJSON(data []byte) error {
        if err := json.Unmarshal(data, &i); err != nil {
                return err
        }
-       switch i.(type) {
-       case float64:
-               f.t = "float64"
-       case string:
-               f.t = "string"
-       }
        value, err := cast.ToFloat64E(i)
        if err != nil {
                return err
@@ -71,12 +67,10 @@ func (f *StringFloat64) Scan(v interface{}) error {
        case float64:
                *f = StringFloat64{
                        v: value,
-                       t: "float64",
                }
        case string:
                *f = StringFloat64{
                        v: cast.ToFloat64(value),
-                       t: "string",
                }
        default:
                return fmt.Errorf("%+v is an unknown type, with value: %v", v, 
value)
diff --git a/backend/helpers/pluginhelper/api/mapstructure.go 
b/backend/helpers/pluginhelper/api/mapstructure.go
index ef9d09456..6f24659e6 100644
--- a/backend/helpers/pluginhelper/api/mapstructure.go
+++ b/backend/helpers/pluginhelper/api/mapstructure.go
@@ -30,6 +30,18 @@ import (
        "github.com/mitchellh/mapstructure"
 )
 
+var defaultCustomDecoderHooks = 
[]mapstructure.DecodeHookFunc{decodeHookStringFloat64, DecodeHook}
+
+func decodeHookStringFloat64(f reflect.Type, t reflect.Type, data interface{}) 
(interface{}, error) {
+       if f.Kind() == reflect.Float64 && t.Kind() == reflect.Struct && t == 
reflect.TypeOf(common.StringFloat64{}) {
+               return *common.NewStringFloat64FromAny(data), nil
+       }
+       if f.Kind() == reflect.Float64 && t.Kind() == reflect.Ptr && t == 
reflect.TypeOf(&common.StringFloat64{}) {
+               return common.NewStringFloat64FromAny(data), nil
+       }
+       return data, nil
+}
+
 func DecodeHook(f reflect.Type, t reflect.Type, data interface{}) 
(interface{}, error) {
        if data == nil {
                return nil, nil
@@ -68,14 +80,13 @@ func DecodeMapStruct(input map[string]interface{}, result 
interface{}, zeroField
        result = models.UnwrapObject(result)
        decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
                ZeroFields:       zeroFields,
-               DecodeHook:       
mapstructure.ComposeDecodeHookFunc(DecodeHook),
+               DecodeHook:       
mapstructure.ComposeDecodeHookFunc(defaultCustomDecoderHooks...),
                Result:           result,
                WeaklyTypedInput: true,
        })
        if err != nil {
                return errors.Convert(err)
        }
-
        if err := decoder.Decode(input); err != nil {
                return errors.Convert(err)
        }