File size: 6,670 Bytes
6c50d1f | 1 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 | import uuid
import re
from model.constant import METHOD_CONST
from model.parameter import Parameter
crud_sort_map = {
"head": 1,
"post": 2,
"get": 3,
"put": 4,
"patch": 5,
"delete": 6,
}
class Method:
def __init__(self, method, path, method_body={}, alternative_method=None):
self.method_type = METHOD_CONST[method]
self.method_path = path
self.method_mapping_path = path
self.method_body = method_body
self.method_id = uuid.uuid4().__str__()
self.method_name = method_body.get("operationId", f'{self.method_type}-{self.method_path}')
self.request_parameters = {}
self.request_parameter_name = set()
self.response_parameter = {}
self.response_parameter_name = set()
self.request_parameter_body_tuple = {}
self.response_parameter_body_tuple = {}
self.feed_from_method = set()
self.output_to_method = set()
self.required_feed_parameter = {}
self.dependency_from_traffic = {}
self.method_signature = f'{self.method_type}-{self.method_path}'
self.crud = crud_sort_map[self.method_type]
# this is used for alternative method.py mapping
if alternative_method:
self.crud = crud_sort_map[alternative_method]
self.parse(self.method_body)
def parse(self, body={}):
# parse request
if body.__contains__("parameters"):
req_parameters = body["parameters"]
req_parameters = self.parse_param(req_parameters)
self.request_parameters = req_parameters
# parse response
responses = body["responses"]
for respon in responses:
format_response = self.parse_response(respon, responses[respon])
print("Response", self.response_parameter_name)
def parse_param(self, parameters=[]):
res = {}
for param in parameters:
name = param["name"]
res[name] = Parameter(name, param, self.method_path)
self.request_parameter_name = set.union(self.request_parameter_name, res[name].parameter_names)
for k in res[name].parameter_body_tuple.keys():
body_tuple_list = self.request_parameter_body_tuple.get(k, [])
body_tuple_list.extend(res[name].parameter_body_tuple[k])
self.request_parameter_body_tuple[k] = body_tuple_list
print("Request", self.request_parameter_name)
return res
def parse_response(self, status_code, response={}):
res = {}
# if self.method_signature == 'get-/rest/blockservice/v1/lun-groups/{id}':
# print()
parameter = Parameter(str(status_code), response, self.method_path)
self.response_parameter[str(status_code)] = parameter
self.response_parameter_name = set.union(self.response_parameter_name, parameter.parameter_names)
self.response_parameter_name.remove(str(status_code))
for k in parameter.parameter_body_tuple.keys():
body_tuple_list = self.response_parameter_body_tuple.get(k, [])
body_tuple_list.extend(parameter.parameter_body_tuple[k])
self.response_parameter_body_tuple[k] = body_tuple_list
return res
def get_parameter_property_name(self, param_property_name=""):
result, candidate_name = None, None
for response in self.response_parameter.values():
if not response.parameter_names.__contains__(param_property_name):
continue
candidate_pool = list(response.attribute_path_dict[param_property_name])
# FIXME: SHOULD BE PROPER HANDLED FOR SPANNING PARAMETER IN DIFFERENT SEQUENCES
result = response.parameter_id + candidate_pool[0]
candidate_name = candidate_pool[0]
assert result
assert candidate_name
return result, candidate_name
def _get_nominal_parameters(self, parameters, with_parameter_name=True):
res = set()
if len(parameters) == 0:
print(self.method_signature, 'has no parameter [in get nominal parameters]')
for parameter in parameters:
for nominal_values in parameter.attribute_path_dict.values():
for value in nominal_values:
if with_parameter_name and value != parameter.name:
res.add(f'{parameter.name}.{value}')
else:
res.add(value)
return res
def get_nominal_request_parameter(self):
return self._get_nominal_parameters(self.request_parameters.values())
def get_request_paramter_by_property_name(self, properties):
res = self._get_nominal_name_by_property_name(properties, self.request_parameters.values(), True)
assert len(res) > 0
return res
def get_response_paramter_by_property_name(self, properties):
res = self._get_nominal_name_by_property_name(properties, self.response_parameter.values())
assert len(res) > 0
return res
def get_single_request_parameter_by_property_name(self, prop):
res = self._get_nominal_name_by_property_name([prop], self.request_parameters.values())
assert len(res) > 0
return res
def get_single_response_parameter_by_property_name(self, prop):
res = self._get_nominal_name_by_property_name([prop], self.response_parameter.values())
assert len(res) > 0
return res
def get_feed_from_method_response_parameter_by_property_and_method_name(self, method_name, prop):
for method in self.feed_from_method:
if method.method_signature == method_name:
return method.get_single_response_parameter_by_property_name(prop)
def _get_nominal_name_by_property_name(self, properties, parameters, with_parameter_name=False):
res = set()
for parameter in parameters:
for prop in properties:
if not parameter.attribute_path_dict.__contains__(prop):
continue
nominal_dict = set()
for attribute in parameter.attribute_path_dict[prop]:
# to avoid add par1.par1 (should add par1 directly)
if with_parameter_name and attribute != parameter.name:
nominal_dict.add(f'{parameter.name}.{attribute}')
else:
nominal_dict.add(attribute)
res = res.union(nominal_dict)
return res
def __str__(self):
return self.method_signature
def __hash__(self):
return hash(self.method_signature)
|