gitee.com/zhongguo168a/gocodes@v0.0.0-20230609140523-e1828349603f/datax/schemax/justify.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  // JustifyObject 如果是数字，会转化成正确的类型
    10  func JustifyObject(obj datax.M, decl *ClassDecl) (result datax.M, err error) {
    11  	return justifyObject(obj, decl)
    12  }
    13  
    14  // todo: 不完整
    15  func justifyObject(obj datax.M, decl *ClassDecl) (datax.M, error) {
    16  	result := datax.M{}
    17  	for _, field := range decl.GetAllField() {
    18  		fname := field.Name
    19  		ival, has := obj[fname]
    20  		if !has && ival == nil {
    21  			continue
    22  		}
    23  		switch ftyp := field.Type.(type) {
    24  		case *ClassType:
    25  			iResult, err := justifyClassType(ival, ftyp)
    26  			if err != nil {
    27  				return nil, errorx.Wrap(err, "justify class", datax.M{"name": fname})
    28  			}
    29  			result[fname] = iResult
    30  		case *ArrayType:
    31  			iResult, err := justifyArrayType(ival, ftyp)
    32  			if err != nil {
    33  				return nil, errorx.Wrap(err, "justify array", datax.M{"name": fname})
    34  			}
    35  			result[fname] = iResult
    36  		case *MapType:
    37  			iResult, err := justifyMapType(ival, ftyp)
    38  			if err != nil {
    39  				return nil, errorx.Wrap(err, "justify map", datax.M{"name": fname})
    40  			}
    41  			result[fname] = iResult
    42  		case *EnumType:
    43  			iResult, err := JustifyEnumType(ival, ftyp)
    44  			if err != nil {
    45  				return nil, errorx.Wrap(err, "justify enum", datax.M{"name": fname})
    46  			}
    47  			result[fname] = iResult
    48  		case *AnyType:
    49  			result[fname] = ival
    50  		case *BasicType:
    51  			tagType := field.Tags["type"]
    52  			switch tagType {
    53  			default:
    54  				iResult, err := justifyBasicType(ival, ftyp)
    55  				if err != nil {
    56  					return nil, errorx.Wrap(err, "justify basic", datax.M{"name": fname})
    57  				}
    58  				result[fname] = iResult
    59  			}
    60  
    61  		}
    62  
    63  	}
    64  
    65  	return result, nil
    66  }
    67  
    68  func justifyClassType(ival interface{}, ftyp *ClassType) (datax.M, error) {
    69  	mval, ok := ival.(map[string]interface{})
    70  	if ok == false {
    71  		return nil, errorx.New("value not map[string]interface{}")
    72  	}
    73  
    74  	typDecl := GetDeclByKey(ftyp.Decl)
    75  	if typDecl == nil {
    76  		return nil, errorx.New("decl not found", datax.M{"class": ftyp.Decl})
    77  	}
    78  
    79  	return justifyObject(mval, typDecl.(*ClassDecl))
    80  }
    81  
    82  func justifyArrayType(ival interface{}, ftyp *ArrayType) ([]interface{}, error) {
    83  	if ival == nil {
    84  		return nil, nil
    85  	}
    86  	arrValue, ok := ival.([]interface{})
    87  	if ok == false {
    88  		return nil, errorx.New("value not []interface{}")
    89  	}
    90  
    91  	newObj := make([]interface{}, len(arrValue))
    92  	for index, val := range arrValue {
    93  		switch etyp := ftyp.Elem.(type) {
    94  		case *ClassType:
    95  			iResult, err := justifyClassType(val, etyp)
    96  			if err != nil {
    97  				return nil, errorx.Wrap(err, "justify map", datax.M{"index": index})
    98  			}
    99  			newObj[index] = iResult
   100  		case *BasicType:
   101  			iResult, err := justifyBasicType(val, etyp)
   102  			if err != nil {
   103  				return nil, errorx.Wrap(err, "justify basic", datax.M{"index": index})
   104  			}
   105  			newObj[index] = iResult
   106  		case *EnumType:
   107  			iResult, err := JustifyEnumType(val, etyp)
   108  			if err != nil {
   109  				return nil, errorx.Wrap(err, "justify map", datax.M{"index": index})
   110  			}
   111  			newObj[index] = iResult
   112  		default:
   113  			return nil, errorx.New("not support type: " + etyp.String())
   114  
   115  		}
   116  		newObj[index] = val
   117  	}
   118  
   119  	return newObj, nil
   120  }
   121  
   122  func justifyMapType(ival interface{}, ftyp *MapType) (datax.M, error) {
   123  	if ival == nil {
   124  		return nil, nil
   125  	}
   126  	mval, ok := ival.(map[string]interface{})
   127  	if ok == false {
   128  		return nil, errorx.New("value not map[string]interface{}")
   129  	}
   130  
   131  	newObj := datax.M{}
   132  	for key, val := range mval {
   133  		switch etyp := ftyp.Value.(type) {
   134  		case *ClassType:
   135  			iResult, err := justifyClassType(val, etyp)
   136  			if err != nil {
   137  				return nil, errorx.Wrap(err, "justify map", datax.M{"key": key})
   138  			}
   139  			newObj[key] = iResult
   140  		case *BasicType:
   141  			iResult, err := justifyBasicType(val, etyp)
   142  			if err != nil {
   143  				return nil, errorx.Wrap(err, "justify basic", datax.M{"key": key})
   144  			}
   145  			newObj[key] = iResult
   146  		case *EnumType:
   147  			iResult, err := JustifyEnumType(val, etyp)
   148  			if err != nil {
   149  				return nil, errorx.Wrap(err, "justify map", datax.M{"key": key})
   150  			}
   151  			newObj[key] = iResult
   152  		default:
   153  			return nil, errorx.New("not support type: " + etyp.String())
   154  
   155  		}
   156  		newObj[key] = val
   157  	}
   158  
   159  	return newObj, nil
   160  }
   161  
   162  func JustifyEnumType(ival interface{}, ftyp *EnumType) (interface{}, error) {
   163  	typDecl := GetDeclByKey(ftyp.Decl)
   164  	if typDecl == nil {
   165  		return nil, errorx.New("decl not found", datax.M{"enum": ftyp.Decl})
   166  	}
   167  	enumDecl := typDecl.(*EnumDecl)
   168  
   169  	return basickind.ConvertKindToStruct(basickind.Kind(enumDecl.Kind), ival), nil
   170  }
   171  func justifyBasicType(ival interface{}, ftyp *BasicType) (interface{}, error) {
   172  	return basickind.ConvertKindToStruct(ftyp.Kind, ival), nil
   173  }