erp5_json_rpc_api: drop commented code

master/bt5/erp5_json_rpc_api/DocumentTemplateItem/portal_components/document.erp5.JsonRpcAPIService.py

@@ -181,133 +181,8 @@ class JsonRpcAPIService(OpenAPIService):
       if (request_method != 'post'):
         raise JsonRpcAPINotAllowedHttpMethod('Only HTTP POST accepted')
 
-    """
-    for operation in self.getTypeInfo().getOpenAPIOperationIterator():
-      if operation.request_method != request_method:
-        continue
-      operation_path_parts = operation.path.split('/')[1:]
-      if len(operation_path_parts) != len(request_path_parts):
-        continue
-      if operation_path_parts == request_path_parts:
-        # this is a concrete match, use this operation
-        request.other['traverse_subpath'] = request_path_parts
-        return operation
-
-      # look for a templated match
-      for operation_path_part, request_path_part in zip(
-          operation_path_parts,
-          request_path_parts,
-      ):
-        if operation_path_part == request_path_part:
-          continue
-        elif operation_path_part[0] == '{' and operation_path_part[-1] == '}':
-          continue
-        # TODO: match paths like /report.{format}
-        else:
-          break
-      else:
-        # we had a match, but there might be a "better" match, so we keep looping.
-        # https://spec.openapis.org/oas/v3.1.0.html#patterned-fields :
-        # > When matching URLs, concrete (non-templated) paths would be matched before
-        # > their templated counterparts
-        matched_operation = operation
-        continue
-    """
-
     return matched_operation
 
-  '''
-  def getMethodForOperation(self, operation):
-    # type: (OpenAPIOperation) -> Optional[Callable]
-    operation_id = operation.get('operationId')
-    if operation_id:
-      method = self._getTypeBasedMethod(operation_id)
-      if method is not None:
-        return method
-    raise NoMethodForOperationError(
-      'No method for operation {operation_id} {request_method} {path}'.format(
-        operation_id=operation.get('operationId', ''),
-        request_method=operation.request_method.upper(),
-        path=operation.path,
-      ))
-
-  def extractParametersFromRequest(self, operation, request):
-    # type: (OpenAPIOperation, HTTPRequest) -> dict
-    parameter_dict = {}
-    for parameter in operation.getParameters():
-      parameter_dict[parameter['name']] = self.validateParameter(
-        'parameter `{}`'.format(parameter['name']),
-        parameter.getValue(request),
-        parameter,
-        parameter.getJSONSchema(),
-      )
-    requestBody = self.validateRequestBody(
-      operation.getRequestBodyValue(request),
-      operation.getRequestBodyJSONSchema(request),
-    )
-    if requestBody:
-      # we try to bind the request body as `body` parameter, but use alternate name
-      # if it's already used by a parameter
-      for body_arg in ('body', 'request_body', 'body_'):
-        if body_arg not in parameter_dict:
-          parameter_dict[body_arg] = requestBody
-          break
-      else:
-        raise SchemaDefinitionError('unable to bind requestBody')
-    return parameter_dict
-
-  security.declareProtected(
-    Permissions.AccessContentsInformation, 'validateParameter')
-
-  def validateParameter(
-      self, parameter_name, parameter_value, parameter, schema):
-    # type: (str, Any, dict, dict) -> Any
-    """Validate the parameter (or request body), raising a ParameterValidationError
-    when the parameter is not valid according to the corresponding schema.
-    """
-    if schema is not None:
-      if parameter_value is None and not parameter.get('required'):
-        return parameter_value
-      __traceback_info__ = (parameter_name, parameter_value, schema)
-      try:
-        jsonschema.validate(parameter_value, schema)
-      except jsonschema.ValidationError as e:
-        raise ParameterValidationError(
-          'Error validating {parameter_name}: {e}'.format(
-            parameter_name=parameter_name, e=e.message), str(e))
-    return parameter_value
-
-  security.declareProtected(
-    Permissions.AccessContentsInformation, 'validateRequestBody')
-
-  def validateRequestBody(self, parameter_value, schema):
-    # type: (str, dict) -> Any
-    """Validate the request body raising a ParameterValidationError
-    when the parameter is not valid according to the corresponding schema.
-    """
-    if schema is not None:
-      if schema.get('type') == 'string':
-        if schema.get('format') == 'base64':
-          try:
-            return base64.b64decode(parameter_value)
-          except (binascii.Error, TypeError) as e:
-            if isinstance(e, TypeError):
-              # BBB on python2 this raises a generic type error
-              # but we don't want to ignore potential TypeErrors
-              # on python3 here
-              if six.PY3:
-                raise
-            raise ParameterValidationError(
-              'Error validating request body: {e}'.format(e=str(e)))
-        elif schema.get('format') == 'binary':
-          return parameter_value or b''
-    return self.validateParameter(
-      'request body',
-      parameter_value,
-      {},
-      schema,
-    )
-'''
   def handleException(self, exception, request):
     if isinstance(exception, JsonRpcAPIError):
       # Prevent catching all exceptions in the script