brreg_grunndata 0.1.0

data/lib/brreg_grunndata/client/response.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative '../utils'
+require_relative 'response_header'
+
+module BrregGrunndata
+  class Client
+    # Wrapper around Savon's response
+    #
+    # Handles unwrapping of XML returned as string
+    class Response
+      using Utils::StringExt
+
+      extend Forwardable
+      def_delegators :@savon_response,
+                     :soap_fault?, :http_error?,
+                     :body
+
+      # Error raised whenever soap or http error occured so
+      # the success? is false but you are still asking for
+      # either header or message
+      class ResponseFailureError < Error; end
+
+      # Error raised when soap communication was a success,
+      # brreg response header indicates success, but for some
+      # reason we didn't get any return value as we expected
+      #
+      # Inspecting #header before calling #message will determin if this error
+      # is to be expected.
+      #
+      # @seehttps://www.brreg.no/produkter-og-tjenester/bestille/tilgang-til-enhetsregisteret-via-web-services/teknisk-beskrivelse-web-services/grunndataws/
+      class MessageEmptyError < Error; end
+
+      def initialize(savon_response)
+        @savon_response = savon_response
+      end
+
+      # Do we have a successful response?
+      #
+      # We do if:
+      #   - We have no HTTP errors or SOAP faults. Savon handles this for us.
+      #   - We have a response_header in the document returned from brreg
+      #     which indicates success too. I don't know why BRREG needs this in
+      #     addition to HTTP status codes and SOAP faults to communicate success
+      #     or not :-(
+      def success?
+        @savon_response.success? && header.success?
+      end
+
+      # Returns the header from brreg's response
+      #
+      # The header contains the overall success of the SOAP operation.
+      # The header is something brreg's SOAP API has, so all in all we have
+      # http status, soap status and then this status located within the header :(
+      def header
+        raise ResponseFailureError unless @savon_response.success?
+
+        ResponseHeader.new response_grunndata[:response_header]
+      end
+
+      # Returns the header from brreg's response
+      #
+      # Keys are symbolized.
+      #
+      # @return Hash
+      def message
+        raise ResponseFailureError unless success?
+
+        @message ||= response_grunndata[:melding] || raise(MessageEmptyError)
+      end
+
+      private
+
+      def response_grunndata
+        @response_grunndata ||= parse(body.values.first[:return])[:grunndata]
+      end
+
+      def parse(xml)
+        parser = Nori.new(
+          strip_namespaces: true,
+          advanced_typecasting: true,
+          convert_tags_to: ->(tag) { tag.underscore.to_sym }
+        )
+
+        parser.parse xml
+      end
+    end
+  end
+end

data/lib/brreg_grunndata/client/response_header.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module BrregGrunndata
+  class Client
+    # Represents a response header from brreg
+    #
+    # A response header has a main status and sub statuses.
+    #
+    # MAIN STATUS:
+    #   0   -   OK
+    #   1   -   OK, but some data is missing. See sub status for details
+    #  -1   -   An error as occured
+    #
+    # @see https://www.brreg.no/produkter-og-tjenester/bestille/tilgang-til-enhetsregisteret-via-web-services/teknisk-beskrivelse-web-services/grunndataws/
+    class ResponseHeader
+      MAIN_STATUS_SUCCESS_CODES = [0, 1].freeze
+
+      def initialize(nori_response_header)
+        @nori_response_header = nori_response_header
+      end
+
+      # Returns true if the brreg response header indicates success.
+      def success?
+        MAIN_STATUS_SUCCESS_CODES.include? main_status
+      end
+
+      def main_status
+        @main_status ||= cast_to_int(@nori_response_header[:hoved_status])
+      end
+
+      def sub_statuses
+        return [] unless @nori_response_header.key? :under_status
+
+        statuses = Array(@nori_response_header[:under_status][:under_status_melding])
+
+        @sub_statuses ||= statuses.map do |status|
+          {
+            code: cast_to_int(status.attributes['kode']),
+            message: status.to_s
+          }
+        end
+      end
+
+      # rubocop:disable Style/LineEndConcatenation
+      def inspect
+        "#<BrregGrunndata::ResponseHeader: main_status: #{main_status} " +
+          "sub_statuses: #{sub_statuses}>"
+      end
+      # rubocop:enable Style/LineEndConcatenation
+
+      private
+
+      def cast_to_int(v)
+        Integer v, 10
+      end
+    end
+  end
+end

data/lib/brreg_grunndata/client/response_validator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module BrregGrunndata
+  class Client
+    class ResponseValidator
+      # Base class for all errors raised if header isn't indicating a success
+      class MainStatusError < Error
+        attr_reader :error_sub_status
+
+        def initialize(error_sub_status)
+          @error_sub_status = error_sub_status
+          super "Error sub status was: '#{error_sub_status}'"
+        end
+      end
+
+      class UnauthorizedError < MainStatusError; end
+      class UnauthenticatedError < MainStatusError; end
+      class UnexpectedError < MainStatusError; end
+
+      # A map of brreg's sub status codes to error class we will raise
+      RESPONSE_SUB_STATUS_CODE_TO_ERROR = {
+        -100  => UnauthorizedError,
+        -101  => UnauthenticatedError,
+        -1000 => UnexpectedError
+      }.freeze
+
+      def initialize(response)
+        @response = response
+        @header = response.header
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def raise_error_or_return_response!
+        return @response if @header.success?
+
+        error_class = nil
+        error_sub_status = nil
+
+        case @header.sub_statuses.length
+        when 0
+          error_sub_status = 'Not included in response'
+          error_class = UnexpectedError
+        when 1
+          error_sub_status = @header.sub_statuses[0]
+          code = error_sub_status[:code]
+          error_class = RESPONSE_SUB_STATUS_CODE_TO_ERROR.fetch(code) { UnexpectedError }
+        else
+          raise Error, "Expected 0 or 1 sub status. Got: #{@header.sub_statuses}"
+        end
+
+        raise error_class, error_sub_status
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/brreg_grunndata/client/sok_enhet_query_to_xml.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'builder'
+
+module BrregGrunndata
+  class Client
+    # Translate a simple query string to an XML document to search with sok_enhet operation
+    #
+    # Given the query "STATOIL" the final XML to be put in soap search_request
+    # will be:
+    #
+    # <![CDATA[
+    #   <?xml version="1.0"?>
+    #   <BrAixXmlRequest RequestName="BrErfrSok">
+    #     <BrErfrSok>
+    #       <BrSokeStreng>STATOIL</BrSokeStreng>
+    #       <MaxTreffReturneres>1000</MaxTreffReturneres>
+    #       <ReturnerIngenHvisMax>true</ReturnerIngenHvisMax>
+    #       <RequestingIPAddr>010.001.052.011</RequestingIPAddr>
+    #       <RequestingTjeneste>SOAP</RequestingTjeneste>
+    #       <MedUnderenheter>true</MedUnderenheter>
+    #     </BrErfrSok>
+    #   </BrAixXmlRequest>
+    # ]]
+    #
+    # Which is great: Now we got a  XML inside XML
+    # payload instead of something simple ;-)
+    #
+    # Attributes
+    #
+    #   query             -   Your search string / query goes here
+    #   first             -   How many do you want to get in return? (the limit)
+    #   include_no_if_max -   Do you want zero results if your search yields more
+    #                         results than the first X you asked for? I don't know
+    #                         why you would want that.
+    #   with_subdivision  -   Do you want to include organization form BEDR og AAFY
+    #                         when you search?
+    #   ip                -   Your client's IP. Seems to work with everything, as
+    #                         long as you have xxx.xxx.xxx.xxx where x is [0-9].
+    class SokEnhetQueryToXml
+      def initialize(query,
+                     first: 100,
+                     include_no_if_max: false,
+                     with_subdivision: true,
+                     ip: '010.001.052.011')
+        @query = query
+        @first = first
+        @ip = ip
+        @include_no_if_max = include_no_if_max
+        @with_subdivision = with_subdivision
+      end
+
+      def cdata
+        "<![CDATA[#{xml}]]>"
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def xml
+        data = {
+          br_aix_xml_request: {
+            :@RequestName => 'BrErfrSok',
+            br_erfr_sok: {
+              br_soke_streng: @query,
+              max_treff_returneres: @first,
+              returner_ingen_hvis_max: true,
+              requesting_IP_addr: @ip,
+              requesting_tjeneste: 'SOAP',
+              med_underenheter: @with_subdivision
+            }
+          }
+        }
+
+        options = { key_converter: :camelcase }
+
+        Gyoku.xml data, options
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/brreg_grunndata/configuration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BrregGrunndata
+  # Contains configuration for the web service client
+  class Configuration
+    # WSDL is located at this URL
+    WSDL_URL = 'https://ws.brreg.no/grunndata/ErFr?WSDL'
+
+    # We have a saved WSDL at this location on disk
+    WSDL_PATH = "#{__dir__}/wsdl/grunndata.xml"
+
+    attr_reader :userid, :password,
+                :open_timeout, :read_timeout,
+                :logger, :log_level,
+                :wsdl
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      userid:,
+      password:,
+      open_timeout: 15,
+      read_timeout: 15,
+      logger: nil,
+      log_level: :info,
+      wsdl: WSDL_PATH
+    )
+      @userid = userid
+      @password = password
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @logger = logger
+      @log_level = log_level
+      @wsdl = wsdl
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/lib/brreg_grunndata/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module BrregGrunndata
+  class Error < StandardError
+  end
+end

data/lib/brreg_grunndata/service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'types/factories'
+require_relative 'utils'
+
+module BrregGrunndata
+  # The service returns ruby objects with data fetched from API
+  #
+  # This interface has a higher abstraction than working directly
+  # with the Client, where the object you get back has coerced values
+  # instead of working with a hash of strings.
+  #
+  # @see Client
+  class Service
+    attr_reader :client
+
+    def initialize(client:)
+      @client = client
+    end
+
+    # Runs given operations concurrently
+    #
+    # Arguments
+    #   operations    -   An array of operations to run concurrently
+    #                     The named operations must be defined as
+    #                     methods on the service and they must return same type.
+    #   args          -   All other arguments are passed on to each operations.
+    def run_concurrently(operations, **args)
+      results = Utils::ConcurrentOperations.new(self, operations, args).call
+
+      return nil if results.any?(&:nil?)
+
+      results.reduce { |acc, elem| acc.merge elem }
+    end
+
+    # Get basic mini data of an organization
+    #
+    # Arguments
+    #   orgnr   - The orgnr you are searching for
+    #
+    # @return BrregGrunndata::Types::Organization
+    def hent_basisdata_mini(orgnr:)
+      Types::FromResponseFactory.organization client.hent_basisdata_mini orgnr: orgnr
+    end
+
+    # Get contact information for an organization
+    #
+    # Arguments
+    #   orgnr   - The orgnr you are searching for
+    #
+    # @return BrregGrunndata::Types::Organization
+    def hent_kontaktdata(orgnr:)
+      Types::FromResponseFactory.organization client.hent_kontaktdata orgnr: orgnr
+    end
+  end
+end

data/lib/brreg_grunndata/types/address.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module BrregGrunndata
+  module Types
+    class Address < Base
+      attribute :street,              Types::String
+      attribute :postal_code,         Types::String
+      attribute :postal_area,         Types::String
+      attribute :municipality_number, Types::String
+      attribute :municipality,        Types::String
+      attribute :country_code,        Types::String
+      attribute :country,             Types::String
+    end
+  end
+end

data/lib/brreg_grunndata/types/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'dry-types'
+
+require_relative '../utils'
+
+module BrregGrunndata
+  module Types
+    # Include Dry basic types
+    #
+    # Whenever you see something like Types::String it is a dry type
+    include Dry::Types.module
+
+    # Base class for all BrregGrunndata's types
+    class Base < Dry::Struct
+      # Allow missing keys in the input data.
+      # Missing data will get default value or nil.
+      constructor_type :schema
+
+      # Merges two base objects together and returns a new instance
+      #
+      # @return a new instance of self, filled/merged with data from other
+      def merge(other)
+        Utils::BaseTypeMerger.new(self, other).merge
+      end
+    end
+  end
+end

data/lib/brreg_grunndata/types/factories.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'organization'
+require_relative 'organizational_form'
+require_relative 'address'
+
+module BrregGrunndata
+  module Types
+    module Factory
+      module_function
+
+      # Creates an organization from given hash
+      #
+      # rubocop:disable Metrics/MethodLength
+      #
+      # @return BrregGrunndata::Types::Organization
+      def organization(h)
+        Organization.new(
+          orgnr: h.fetch(:organisasjonsnummer),
+          organizational_form: organizational_form(h[:organisasjonsform]),
+
+          name: h.dig(:navn, :navn1),
+
+          telephone_number: h[:telefonnummer],
+          telefax_number: h[:telefaksnummer],
+          mobile_number: h[:mobiltelefonnummer],
+          email: h[:epostadresse],
+          web_page: h[:hjemmesideadresse],
+
+          business_address: business_address(h[:forretnings_adresse]),
+          postal_address: postal_address(h[:post_adresse])
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Creates a address for given Hash
+      #
+      # @return BrregGrunndata::Types::Address
+      def business_address(hash)
+        __address hash
+      end
+
+      # Creates a address for given Hash
+      #
+      # @return BrregGrunndata::Types::Address
+      def postal_address(hash)
+        __address hash
+      end
+
+      # Creates a organizational form for given Hash
+      #
+      # @return BrregGrunndata::Types::OrganizationalForm
+      def organizational_form(h)
+        return nil if h.nil?
+
+        OrganizationalForm.new(
+          name: h[:orgform],
+          description: h[:orgform_beskrivelse]
+        )
+      end
+
+      # As of writing, keys for postal and business address
+      # are the same, so the are both initialized here
+      def __address(h)
+        return nil if h.nil?
+
+        Address.new(
+          street: h[:adresse1],
+          postal_code: h[:postnr],
+          postal_area: h[:poststed],
+          municipality_number: h[:kommunenummer],
+          municipality: h[:kommune],
+          country_code: h[:landkode],
+          country: h[:land]
+        )
+      end
+    end
+
+    # Contains methods for extracting datafrom client responses
+    # and building defined types from it.
+    module FromResponseFactory
+      module_function
+
+      # Creates an organization from given response
+      #
+      # @return BrregGrunndata::Types::Organization
+      def organization(response)
+        Factory.organization response.message
+      rescue Client::Response::MessageEmptyError
+        nil
+      end
+    end
+  end
+end