pagopa-soap 0.1.0

data/lib/pago_pa/soap/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module PagoPA; end
+module PagoPA::SOAP; end
+
+module PagoPA::SOAP
+  VERSION = "0.1.0"
+end

data/lib/pago_pa/soap/wsdl_loader.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module PagoPA; end
+module PagoPA::SOAP; end
+
+class PagoPA::SOAP::WSDLLoader
+  attr_reader :wsdl_base
+  attr_reader :wsdl_notify
+  attr_reader :namespace
+
+  def initialize(options = {})
+    @wsdl_base = options[:wsdl_base] || PagoPA::SOAP.config.wsdl_base
+    @wsdl_notify = options[:wsdl_notify] || PagoPA::SOAP.config.wsdl_notify
+    @namespace = options[:namespace] || PagoPA::SOAP.config.namespace
+
+    validate_wsdl_base!
+    validate_wsdl_notify!
+  end
+
+  def build
+    soap_base.build
+    soap_notify.build
+  end
+
+  def requests
+    soap_base.request + soap_notify.request
+  end
+
+  def clients
+    soap_base.client + soap_notify.client
+  end
+
+  def responses
+    soap_base.response + soap_notify.response
+  end
+
+  private
+
+  def soap_base
+    @soap_base ||=
+      Soap::Base.new(
+        wsdl: wsdl_base,
+        namespace: namespace,
+        endpoint: PagoPA::SOAP.config.endpoint_base
+      )
+  end
+
+  def soap_notify
+    @soap_notify ||=
+      Soap::Base.new(
+        wsdl: wsdl_notify,
+        namespace: namespace,
+        endpoint: PagoPA::SOAP.config.endpoint_notify
+      )
+  end
+
+  def validate_wsdl_base!
+    raise "Error: WSDL is empty" if !@wsdl_base.instance_of?(String)
+    raise "Error: File not exists" if !File.exists?(@wsdl_base)
+  end
+
+  def validate_wsdl_notify!
+    raise "Error: WSDL is empty" if !@wsdl_notify.instance_of?(String)
+    raise "Error: File not exists" if !File.exists?(@wsdl_notify)
+  end
+end

data/lib/soap.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "gyoku"
+require "nori"
+require "soap/string"
+
+# Parser
+require "soap/parser"
+require "soap/parser/types"
+require "soap/parser/port_type"
+require "soap/parser/binding"
+require "soap/parser/message"
+require "soap/parser/service"
+
+# WebService
+require "soap/webservice/request"
+require "soap/webservice/response"
+require "soap/webservice/client"
+require "soap/webservice/error"
+require "soap/webservice/fault_error"
+
+module Soap
+  class << self
+    def to_snakecase(str)
+      Soap::String.snakecase(str)
+    end
+
+    def to_camelcase(str)
+      Soap::String.camelcase(
+        Soap.to_snakecase(str)
+      )
+    end
+
+    def to_wsdl_camelcase(str)
+      Soap::String.wsdl_camelcase(
+        Soap.to_snakecase(str)
+      )
+    end
+  end
+end
+
+class Soap::Base
+  SUB_CLASSES = %i[request client response].freeze
+  attr_reader :wsdl
+  attr_reader :namespace
+  attr_reader :endpoint
+
+  def initialize(wsdl:, namespace:, endpoint: nil)
+    @wsdl = wsdl
+    @namespace = namespace
+    @endpoint = endpoint
+  end
+
+  def build
+    ns_module =
+      if Object.const_defined?(namespace)
+        Object.const_get(namespace)
+      else
+        Object.const_set(namespace, Module.new)
+      end
+    parser.soap_actions.each do |action|
+      build_klass(ns_module, action, parser.soap_action(action), endpoint)
+    end
+    true
+  end
+
+  def build_klass(mod, name, action, endpoint)
+    service_name = parser.service[:base_endpoint]
+    k_mod = mod.const_set(Soap.to_camelcase(name), Module.new)
+    build_custom_klass(k_mod, "Request", action[:input])
+    build_custom_klass(k_mod, "Response", action[:output])
+
+    klass = Class.new(Soap::Webservice::Client) do
+      define_singleton_method :namespace do
+        if !endpoint.blank?
+          endpoint
+        else
+          service_name
+        end
+      end
+
+      define_singleton_method :action do
+        action[:input][:port_type][:name]
+      end
+
+      define_method :response do
+        @response ||= k_mod.const_get("Response")
+      end
+
+      # rubocop:disable all
+      private :response
+      # rubocop:enable all
+    end
+    k_mod.const_set("Client", klass)
+  end
+
+  def build_custom_klass(mod, type_klass, action_klass)
+    klass = Class.new(Object.const_get("Soap::Webservice::#{type_klass}")) do
+      define_singleton_method :body_attributes do
+        action_klass[:types][:body]
+      end
+
+      define_singleton_method :header_attributes do
+        action_klass[:types][:header]
+      end
+    end
+
+    mod.const_set(type_klass.to_s, klass)
+  end
+
+  SUB_CLASSES.each do |sub_class|
+    define_method(sub_class) do
+      name = Soap.to_camelcase(sub_class.to_s)
+      parser.soap_actions.map do |action|
+        "#{namespace}::#{Soap.to_camelcase(action)}::#{name}"
+      end
+    end
+  end
+
+  private
+
+  def parser
+    @parser ||= Soap::Parse.new(File.read(wsdl))
+  end
+end

data/lib/soap/parser.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Soap; end
+module Soap::Parser; end
+
+class Soap::Parse
+  COMMON_ATTRIBUTES = %i[input output].freeze
+  DEFAULT_SECTIONS = %w[types message port_type binding service].freeze
+  attr_reader :document
+
+  def initialize(file)
+    @document = Nokogiri::XML(file)
+  end
+
+  def namespaces
+    @namespaces = @document.namespaces.inject({}) do |memo, (key, value)|
+      memo[key.sub("xmlns:", "")] = value
+      memo
+    end
+  end
+
+  DEFAULT_SECTIONS.each do |sec|
+    define_method(sec.to_sym) do
+      sec_klass = Object.const_get("Soap::Parser::#{Soap.to_camelcase(sec)}")
+      sec_result = sec_klass.new(namespaces, section(sec))
+      sec_result.parse
+      sec_result.hash
+    end
+  end
+
+  def soap_actions
+    port_type.keys.map do |pt|
+      pt
+    end
+  end
+
+  def soap_action(name)
+    Soap::Parse::COMMON_ATTRIBUTES.each.with_object({}) do |common, attrs|
+      attrs[common] = {
+        port_type: port_type[name][common],
+        binding: binding[:operations][name][common],
+        message: message[port_type[name][common][:message].split(":").last],
+        types: extract_types_attribute(name, common)
+      }
+    end
+  end
+
+  def extract_types_attribute(name, io)
+    msg_name = port_type[name][io][:message].split(":").last
+    components = binding[:operations][name][io]
+    ext = {}
+    components.map do |k, v|
+      component = message[msg_name][:part]
+      if v[:part].nil? && v[:parts].nil?
+        namespace, params = component.values.first.split(":")
+      else
+        namespace, params = component[v[:part] || v[:parts]].split(":")
+      end
+      ext[k.to_sym] = types[namespace][params][:params]
+    end
+    ext
+  end
+
+  def section(section_name)
+    sections[section_name] || []
+  end
+
+  def sections
+    @sections ||=
+      @document.root.element_children.each.with_object({}) do |node, attrs|
+        (attrs[Soap.to_snakecase(node.name)] ||= []) << node
+      end
+  end
+end

data/lib/soap/parser/binding.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Soap; end
+module Soap::Parser; end
+
+class Soap::Parser::Binding
+  COMPONENT_ATTRIBUTES = %i[part parts message].freeze
+  attr_accessor :hash
+  attr_reader :node
+
+  def initialize(_namespaces, node)
+    @node = node
+    @hash = {}
+  end
+
+  def parse
+    parse_binding
+  end
+
+  def parse_binding
+    return if @node.empty? && @node.first.nil?
+    binding_node = @node.first
+
+    @hash[:name] = binding_node["name"]
+    @hash[:type] = binding_node["type"]
+    operations = Hash[binding_node.xpath("./wsdl:operation").map do |operation|
+      [operation["name"], {
+        input: parse_input_output(operation, "input"),
+        output: parse_input_output(operation, "output")
+      }]
+    end]
+    @hash[:operations] = operations
+  end
+
+  def parse_input_output(node, type)
+    type_node = node.element_children.find { |ec| ec.name == type }
+
+    Hash[type_node.element_children.map do |elem|
+      [elem.name, parse_attribute(elem)]
+    end]
+  end
+
+  def parse_attribute(node)
+    attributes =
+      COMPONENT_ATTRIBUTES.each.with_object({}) do |attr, attrs|
+        value = node.attribute(attr.to_s)
+        attrs[attr] = value.to_s if value
+      end
+    attributes[:name] = node.parent["name"]
+
+    attributes
+  end
+end

data/lib/soap/parser/message.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Soap; end
+module Soap::Parser; end
+
+class Soap::Parser::Message
+  attr_accessor :hash
+  attr_reader :node
+
+  def initialize(_namespaces, node)
+    @node = node
+    @hash = {}
+  end
+
+  def parse
+    parse_message
+  end
+
+  def parse_message
+    @hash = Hash[@node.map do |node|
+      [node["name"], Hash[:part, Hash[node.element_children.map do |mec|
+        [mec["name"], mec.attribute("element").value]
+      end
+      ]]]
+    end]
+  end
+end

data/lib/soap/parser/port_type.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Soap; end
+module Soap::Parser; end
+
+class Soap::Parser::PortType
+  attr_accessor :hash
+  attr_reader :node
+
+  def initialize(_namespaces, node)
+    @node = node
+    @hash = {}
+  end
+
+  def parse
+    parse_port_types
+  end
+
+  def parse_port_types
+    return if @node.empty? && @node.first.nil?
+    node_elements =
+      node.first.element_children.select do |op|
+        op.name == "operation"
+      end
+
+    @hash = Hash[node_elements.map do |operation|
+      [operation["name"], {
+        input: parse_input_or_output(operation, "input"),
+        output: parse_input_or_output(operation, "output")
+      }]
+    end]
+  end
+
+  def parse_input_or_output(node, type)
+    node_type = node.element_children.find { |n| n.name == type }
+    {
+      name: node_type.attribute("message").to_s.split(":").last,
+      message: node_type.attribute("message").to_s,
+      action: node_type.attribute("Action").to_s
+    }
+  end
+end

data/lib/soap/parser/service.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Soap; end
+module Soap::Parser; end
+
+class Soap::Parser::Service
+  attr_accessor :hash
+  attr_reader :node
+
+  def initialize(_namespaces, node)
+    @node = node
+    @hash = {}
+  end
+
+  def parse
+    parse_service
+  end
+
+  def parse_service
+    address = node.first.at_xpath("./wsdl:port/soap:address")
+    @hash = {
+      base_endpoint: address["location"]
+    }
+  end
+end

data/lib/soap/parser/types.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Soap; end
+module Soap::Parser; end
+
+class Soap::Parser::Types
+  VALIDATION_ATTRIBUTES = %i[nillable default minOccurs maxOccurs].freeze
+
+  attr_accessor :hash
+  attr_reader :node
+  attr_reader :namespaces
+
+  def initialize(namespaces, node)
+    @namespaces = namespaces
+    @node = node
+    @hash = {}
+  end
+
+  def parse
+    parse_types
+  end
+
+  def parse_types
+    schemas.each do |schema|
+      namespace = @namespaces.key(schema["targetNamespace"])
+      @hash[namespace] = {}
+      schema.element_children.each do |node|
+        case node.name
+        when "element"
+          if !node.children.empty?
+            node_type = node.at_xpath("./xsd:complexType")
+          else
+            complex_type = node.attribute("type").to_s
+            node_type = schema.at_xpath(
+              "xsd:complexType[@name='#{complex_type.split(':').last}']"
+            )
+          end
+          @hash[namespace].merge!(parse_type(node_type, node["name"]))
+        when "complexType"
+          @hash[namespace].merge!(parse_type(node, node["name"]))
+        end
+      end
+    end
+  end
+
+  def simple_type
+    { "base" => @node.at_xpath("./xs|xsd:restriction")["base"] }
+  end
+
+  # rubocop:disable all
+  def parse_type(node, name)
+    element = {}
+    element[name] ||= { params: [] }
+    node.xpath("./xsd:complexContent/xsd:extension/xsd:sequence/xsd:element").each do |inner|
+      elem_name = inner.attribute("name").to_s
+      elem_type = inner.attribute("type").to_s
+      elem_attributes =
+        VALIDATION_ATTRIBUTES.each.with_object({}) do |attr, attrs|
+          value = inner.attribute(attr.to_s)
+          attrs[attr] = value.to_s if value
+        end
+
+      element[name][:params] << {
+        name: elem_name,
+        type: elem_type,
+        attributes: elem_attributes
+      }
+    end
+
+    node.xpath("./xsd:sequence/xsd:element").each do |inner|
+      elem_name = inner.attribute("name").value
+      elem_type = inner.attribute("type").value
+      elem_attributes =
+        VALIDATION_ATTRIBUTES.each.with_object({}) do |attr, attrs|
+          value = inner.attribute(attr.to_s)
+          attrs[attr] = value.to_s if value
+        end
+
+      element[name][:params] << {
+        name: elem_name,
+        type: elem_type,
+        attributes: elem_attributes
+      }
+    end
+
+    element
+  end
+  # rubocop:enable all
+
+  private
+
+  def schemas
+    return [] if @node.empty? && @node.first.nil?
+    types = @node.first
+    types ? types.element_children : []
+  end
+end