class Code(object):

MSG = { }

@classmethod

def api_resp(cls, code=0, msg=None, data=None):

if codeis None:

reason = cls.MSG.get(result, '')

return ApiResp(result, reason, resp)

def safe_int(val):

if isinstance(val, (int, long)):

return val

if isinstance(val, basestring):

val = val.strip()

try:

if isinstance(val, basestring) and "." in val:

return int(float(val))

return int(val)

except Exception:

raise ValidateException(Code.invalid_params, 'safe_int error ,'

'val:{0}'.format(val))

def safe_float(val):

if isinstance(val, float):

return val

if isinstance(val, (int, long)):

return float(val)

if isinstance(val, basestring):

val = val.strip()

try:

return float(val)

except Exception:

raise ValidateException(Code.invalid_params, 'safe_float error ,'

'val:{0}'.format(val))

def safe_str(val, encodeing="utf-8"):

try:

if not isinstance(val, basestring):

return str(val)

if isinstance(val, unicode):

return val.encode(encodeing, "replace")

return val

except Exception:

raise ValidateException(Code.invalid_params, 'safe_str error ,'

'val:{0}'.format(val))

class ArgsTypeConsts(object):

STR = 'str'

INT = 'int'

FLOAT = 'float'

OBJ = 'object'

ARRAY = 'array'

class ArgsResolver(object):

def __init__(self, input_obj, obj_desc):

'''

:param input_obj: 输入需要校验的对象

:param obj_desc: 校验描述对象

'''

self.not_null(input_obj, 'input_obj').not_null(obj_desc,

'obj_desc')

self.input_obj = input_obj

self.obj_desc = obj_desc

def resolve(self):

return self.resolve_obj(self.input_obj, self.obj_desc)

def resolve_obj(self, ipt_obj, obj_desc):

if not obj_desc:

return ipt_obj

opt_obj = {}

for arg_desc in obj_desc:

name = arg_desc['name']

val = ipt_obj.get(name)

val = self.resolve_obj_entry(val, arg_desc)

opt_obj[name] = val

return opt_obj

def not_null(self, val, name='param'):

if val is None:

raise ValidateException(Code.invalid_params, '{0} can not be ' \

'null'.format(name))

return self

def ensure_arr(self, val, name='param'):

if not isinstance(val, (list, set)):

raise ValidateException(Code.invalid_params,

'{0} should be array:{1}'.format(

name, val))

def ensure_obj(self, val, name='param'):

if not isinstance(val, dict):

raise ValidateException(Code.invalid_params, '{0} should be '

'object:{1}'.format(

name, val))

def resolve_obj_entry(self, key_val, arg_desc):

name = arg_desc['name']

_type = arg_desc['type']

default_val = arg_desc.get('default', None)

def_required = 'default' not in arg_desc

required = arg_desc.get('required', def_required)

# 1.检查 是否必须

if required:

self.not_null(key_val, name)

# 2.检查是否需要设值默认值

if not required and key_val is None and default_val is not None:

# 非必须 key_val 为空 配置了 default_val

key_val = default_val

# 3. 检查类型

if key_val is not None:

if _type == ArgsTypeConsts.STR:

key_val = safe_str(key_val)

elif _type == ArgsTypeConsts.INT:

key_val = safe_int(key_val)

elif _type == ArgsTypeConsts.FLOAT:

key_val = safe_float(key_val)

elif _type == ArgsTypeConsts.OBJ:

# 确保是对象

self.ensure_obj(key_val, name)

object_desc = arg_desc.get('object_desc', None)

key_val = self.resolve_obj(key_val, object_desc)

elif _type == ArgsTypeConsts.ARRAY:

# 确保是数组

self.ensure_arr(key_val, name)

array_desc = arg_desc.get('array_desc')

key_val = self.resolve_arr(key_val, array_desc)

else:

raise ValidateException(Code.invalid_params,

'unknow type:{0}'.format(

_type))

return key_val

def resolve_arr(self, ipt_arr, arr_desc):

if not arr_desc:

return ipt_arr

opt_arr = []

_type = arr_desc.get('type')

for key_val in ipt_arr:

if _type == ArgsTypeConsts.STR:

key_val = safe_str(key_val)

opt_arr.append(key_val)

elif _type == ArgsTypeConsts.INT:

key_val = safe_int(key_val)

opt_arr.append(key_val)

elif _type == ArgsTypeConsts.FLOAT:

key_val = safe_float(key_val)

opt_arr.append(key_val)

elif _type == ArgsTypeConsts.OBJ:

# 确保是对象

self.ensure_obj(key_val)

object_desc = arr_desc.get('object_desc', None)

key_val = self.resolve_obj(key_val, object_desc)

opt_arr.append(key_val)

elif _type == ArgsTypeConsts.ARRAY:

# 确保是数组

self.ensure_arr(key_val)

array_desc = arr_desc.get('array_desc', None)

key_val = self.resolve_arr(key_val, array_desc)

opt_arr.append(key_val)

else:

raise ValidateException(Code.invalid_params, 'unknow type:{' \

'0}'.format(type))

return opt_arr

if __name__ == '__main__':

desc = [

# {'name': 'x', 'type': 'float', 'required': True, },

{'name': 'y', 'type': 'object', 'required': True,

'object_desc': [

{'name': 'a', 'type': 'int', 'required': True},

{'name': 'b', 'type': 'array', 'required': True,

'array_desc': {

'type': 'str'

}},

{'name': 'c', 'type': 'array', 'required': True,

'array_desc': {

'type': 'object',

'object_desc': [

{'name': 'a', 'type': 'int', 'required': True},

]

}}

]},

]

data = {

"x": "3.12",

"y": {

'a': '1',

'b': ['1', 2],

'c': [{'a': '1'}]

}

}

resolver = ArgsResolver(data, desc)

api_resp = None

try:

resolved_data = resolver.resolve()

api_resp = Code.api_resp(resp=resolved_data)

except ValidateException as v:

api_resp = Code.api_resp(v.result, v.reason)

print 'api_resp===\n', api_resp1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209