class SOAP::RPC::Router::Operation

Attributes

name[R]
request_style[R]
request_use[R]
response_style[R]
response_use[R]
soapaction[R]

Public Class Methods

new(soapaction, name, param_def, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 342
def initialize(soapaction, name, param_def, opt)
  @soapaction = soapaction
  @name = name
  @request_style = opt[:request_style]
  @response_style = opt[:response_style]
  @request_use = opt[:request_use]
  @response_use = opt[:response_use]
  check_style(@request_style)
  check_style(@response_style)
  check_use(@request_use)
  check_use(@response_use)
  if @response_style == :rpc
    request_qname = opt[:request_qname] or raise
    @rpc_method_factory =
      RPC::SOAPMethodRequest.new(request_qname, param_def, @soapaction)
    @rpc_response_qname = opt[:response_qname]
  else
    @doc_request_qnames = []
    @doc_request_qualified = []
    @doc_response_qnames = []
    @doc_response_qualified = []
    param_def.each do |inout, paramname, typeinfo, eleinfo|
      klass, nsdef, namedef = typeinfo
      qualified = eleinfo
      case inout
      when SOAPMethod::IN
        @doc_request_qnames << XSD::QName.new(nsdef, namedef)
        @doc_request_qualified << qualified
      when SOAPMethod::OUT
        @doc_response_qnames << XSD::QName.new(nsdef, namedef)
        @doc_response_qualified << qualified
      else
        raise ArgumentError.new(
          "illegal inout definition for document style: #{inout}")
      end
    end
  end
end

Public Instance Methods

call(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 389
def call(body, mapping_registry, literal_mapping_registry, opt)
  if @request_style == :rpc
    values = request_rpc(body, mapping_registry, literal_mapping_registry,
      opt)
  else
    values = request_document(body, mapping_registry,
      literal_mapping_registry, opt)
  end
  result = receiver.method(@name.intern).call(*values)
  return result if result.is_a?(SOAPFault)
  if @response_style == :rpc
    response_rpc(result, mapping_registry, literal_mapping_registry, opt)
  else
    response_doc(result, mapping_registry, literal_mapping_registry, opt)
  end
end
request_default_encodingstyle() click to toggle source
# File lib/soap/rpc/router.rb, line 381
def request_default_encodingstyle
  (@request_use == :encoded) ? EncodingNamespace : LiteralNamespace
end
response_default_encodingstyle() click to toggle source
# File lib/soap/rpc/router.rb, line 385
def response_default_encodingstyle
  (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
end

Private Instance Methods

check_style(style) click to toggle source
# File lib/soap/rpc/router.rb, line 549
def check_style(style)
  unless [:rpc, :document].include?(style)
    raise ArgumentError.new("unknown style: #{style}")
  end
end
check_use(use) click to toggle source
# File lib/soap/rpc/router.rb, line 555
def check_use(use)
  unless [:encoded, :literal].include?(use)
    raise ArgumentError.new("unknown use: #{use}")
  end
end
receiver() click to toggle source
# File lib/soap/rpc/router.rb, line 408
def receiver
  raise NotImplementedError.new('must be defined in derived class')
end
request_doc_enc(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 446
def request_doc_enc(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
request_doc_lit(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 452
def request_doc_lit(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
request_document(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 424
def request_document(body, mapping_registry, literal_mapping_registry, opt)
  # ToDo: compare names with @doc_request_qnames
  if @request_use == :encoded
    request_doc_enc(body, mapping_registry, opt)
  else
    request_doc_lit(body, literal_mapping_registry, opt)
  end
end
request_rpc(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 412
def request_rpc(body, mapping_registry, literal_mapping_registry, opt)
  request = body.request
  unless request.is_a?(SOAPStruct)
    raise RPCRoutingError.new("not an RPC style")
  end
  if @request_use == :encoded
    request_rpc_enc(request, mapping_registry, opt)
  else
    request_rpc_lit(request, literal_mapping_registry, opt)
  end
end
request_rpc_enc(request, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 433
def request_rpc_enc(request, mapping_registry, opt)
  param = Mapping.soap2obj(request, mapping_registry, nil, opt)
  request.collect { |key, value|
    param[key]
  }
end
request_rpc_lit(request, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 440
def request_rpc_lit(request, mapping_registry, opt)
  request.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
response_doc(result, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 466
def response_doc(result, mapping_registry, literal_mapping_registry, opt)
  if @doc_response_qnames.size == 1 and !result.is_a?(Array)
    result = [result]
  end
  if result.size != @doc_response_qnames.size
    raise "required #{@doc_response_qnames.size} responses " +
      "but #{result.size} given"
  end
  if @response_use == :encoded
    response_doc_enc(result, mapping_registry, opt)
  else
    response_doc_lit(result, literal_mapping_registry, opt)
  end
end
response_doc_enc(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 529
def response_doc_enc(result, mapping_registry, opt)
  (0...result.size).collect { |idx|
    ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt)
    ele.elename = @doc_response_qnames[idx]
    ele
  }
end
response_doc_lit(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 537
def response_doc_lit(result, mapping_registry, opt)
  (0...result.size).collect { |idx|
    ele = Mapping.obj2soap(result[idx], mapping_registry,
      @doc_response_qnames[idx])
    ele.encodingstyle = LiteralNamespace
    if ele.respond_to?(:qualified)
      ele.qualified = @doc_response_qualified[idx]
    end
    ele
  }
end
response_rpc(result, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 458
def response_rpc(result, mapping_registry, literal_mapping_registry, opt)
  if @response_use == :encoded
    response_rpc_enc(result, mapping_registry, opt)
  else
    response_rpc_lit(result, literal_mapping_registry, opt)
  end
end
response_rpc_enc(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 481
def response_rpc_enc(result, mapping_registry, opt)
  soap_response =
    @rpc_method_factory.create_method_response(@rpc_response_qname)
  if soap_response.have_outparam?
    unless result.is_a?(Array)
      raise RPCRoutingError.new("out parameter was not returned")
    end
    outparams = {}
    i = 1
    soap_response.output_params.each do |outparam|
      outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
        nil, opt)
      i += 1
    end
    soap_response.set_outparam(outparams)
    soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
      nil, opt)
  else
    soap_response.retval = Mapping.obj2soap(result, mapping_registry, nil,
      opt)
  end
  soap_response
end
response_rpc_lit(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 505
def response_rpc_lit(result, mapping_registry, opt)
  soap_response =
    @rpc_method_factory.create_method_response(@rpc_response_qname)
  if soap_response.have_outparam?
    unless result.is_a?(Array)
      raise RPCRoutingError.new("out parameter was not returned")
    end
    outparams = {}
    i = 1
    soap_response.output_params.each do |outparam|
      outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
        XSD::QName.new(nil, outparam), opt)
      i += 1
    end
    soap_response.set_outparam(outparams)
    soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
      XSD::QName.new(nil, soap_response.elename), opt)
  else
    soap_response.retval = Mapping.obj2soap(result, mapping_registry,
      XSD::QName.new(nil, soap_response.elename), opt)
  end
  soap_response
end