gitee.com/zhongguo168a/gocodes@v0.0.0-20230609140523-e1828349603f/datax/schemax/check.go (about)

     1  package schemax
     2  
     3  import (
     4  	"gitee.com/zhongguo168a/gocodes/datax"
     5  	"gitee.com/zhongguo168a/gocodes/datax/schemax/basickind"
     6  	"gitee.com/zhongguo168a/gocodes/myx/errorx"
     7  )
     8  
     9  // 如果是数字，会转化成正确的类型
    10  func CheckType(valType IType, val interface{}) (err error) {
    11  	switch typ := valType.(type) {
    12  	case *EnumType:
    13  		err = checkEnumType(typ, val)
    14  	case *BasicType:
    15  		err = checkBasicType(typ, val)
    16  
    17  	}
    18  	return err
    19  }
    20  
    21  // 如果是数字，会转化成正确的类型
    22  func CheckObject(obj datax.M, decl *ClassDecl) (err error) {
    23  	return checkObject(obj, decl)
    24  }
    25  
    26  // todo: 不完整
    27  func checkObject(obj datax.M, decl *ClassDecl) error {
    28  	for _, field := range decl.GetAllField() {
    29  		fname := field.Name
    30  		val, has := obj[fname]
    31  		if !has && val == nil {
    32  			continue
    33  		}
    34  		var err error
    35  		switch typ := field.Type.(type) {
    36  		case *ClassType:
    37  			typDecl := GetDeclByKey(typ.Decl)
    38  			if typDecl == nil {
    39  				return errorx.New("decl not found", datax.M{"name": fname, "class": typ.Decl})
    40  			}
    41  			mval, ok := val.(map[string]interface{})
    42  			if ok == false {
    43  				return errorx.New("map value not map[string]interface{}", datax.M{"name": fname})
    44  			}
    45  			classErr := checkObject(mval, typDecl.(*ClassDecl))
    46  			if classErr != nil {
    47  				return errorx.Wrap(err, "check class", datax.M{"name": fname, "class": typ.Decl})
    48  			}
    49  		case *MapType:
    50  		case *EnumType:
    51  			err = checkEnumType(typ, val)
    52  		case *BasicType:
    53  			err = checkBasicType(typ, val)
    54  		}
    55  
    56  		if err != nil {
    57  			return errorx.Wrap(err, "check field", datax.M{"name": fname})
    58  		}
    59  	}
    60  
    61  	return nil
    62  }
    63  
    64  func checkEnumType(typ *EnumType, val interface{}) error {
    65  	iedecl := GetDeclByKey(typ.Decl)
    66  	if iedecl == nil {
    67  		return errorx.New("decl not found", datax.M{"decl": typ.Decl})
    68  	}
    69  	edecl := iedecl.(*EnumDecl)
    70  	kind := basickind.Kind(edecl.Kind)
    71  	switch kind {
    72  	case basickind.Int8:
    73  		fallthrough
    74  	case basickind.Int16:
    75  		fallthrough
    76  	case basickind.Int32:
    77  		fallthrough
    78  	case basickind.Int64:
    79  		fallthrough
    80  	case basickind.Uint8:
    81  		fallthrough
    82  	case basickind.Uint16:
    83  		fallthrough
    84  	case basickind.Uint32:
    85  		fallthrough
    86  	case basickind.Uint64:
    87  		switch val.(type) {
    88  		case int:
    89  		default:
    90  			return errorx.New("not number")
    91  		}
    92  	case basickind.String:
    93  		switch val.(type) {
    94  		case string:
    95  		default:
    96  			return errorx.New("not string")
    97  		}
    98  	}
    99  
   100  	return nil
   101  }
   102  
   103  func checkBasicType(typ *BasicType, val interface{}) error {
   104  	switch typ.Kind {
   105  	case basickind.Bool:
   106  		switch val.(type) {
   107  		case bool:
   108  		default:
   109  			return errorx.New("not bool")
   110  		}
   111  	case basickind.Int8:
   112  		fallthrough
   113  	case basickind.Int16:
   114  		fallthrough
   115  	case basickind.Int32:
   116  		fallthrough
   117  	case basickind.Int64:
   118  		fallthrough
   119  	case basickind.Uint8:
   120  		fallthrough
   121  	case basickind.Uint16:
   122  		fallthrough
   123  	case basickind.Uint32:
   124  		fallthrough
   125  	case basickind.Uint64:
   126  		switch val.(type) {
   127  		case int:
   128  		case float64:
   129  		case string:
   130  		default:
   131  			return errorx.New("not number")
   132  		}
   133  	case basickind.Float32:
   134  		fallthrough
   135  	case basickind.Float64:
   136  		switch val.(type) {
   137  		case int:
   138  		case float64:
   139  		default:
   140  		}
   141  	case basickind.String:
   142  		switch val.(type) {
   143  		case string:
   144  		default:
   145  			return errorx.New("not string")
   146  		}
   147  	}
   148  
   149  	return nil
   150  }