czech_post_b2b_client 1.0.0

data/lib/czech_post_b2b_client/response_parsers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'czech_post_b2b_client/response_parsers/base_parser'
+require 'czech_post_b2b_client/response_parsers/get_stats_parser'
+require 'czech_post_b2b_client/response_parsers/get_parcels_printing_parser'
+require 'czech_post_b2b_client/response_parsers/get_parcel_state_parser'
+require 'czech_post_b2b_client/response_parsers/get_result_parcels_parser'
+require 'czech_post_b2b_client/response_parsers/send_parcels_parser'

data/lib/czech_post_b2b_client/response_parsers/base_parser.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'ox'
+
+module CzechPostB2bClient
+  module ResponseParsers
+    class BaseParser < SteppedService::Base
+      def initialize(xml:)
+        @response_xml = xml
+      end
+
+      def steps
+        %i[parse_xml safely_build_result]
+      end
+
+      private
+
+      attr_accessor :response_xml, :response_hash
+
+      def parse_xml
+        @response_hash = Ox.load(response_xml,
+                                 strip_namespace: true,
+                                 symbolize_keys: false,
+                                 mode: :hash_no_attrs)
+      rescue Ox::ParseError => error
+        handle_parsing_error(error)
+      end
+
+      def safely_build_result
+        build_result
+      rescue NoMethodError => error # NoMethodError: undefined method `dig' for nil:NilClass
+        handle_result_building_error(error)
+      end
+
+      def build_result
+        @result = {
+          request: { created_at: request_data.time_stamp,
+                     contract_id: request_data.id_contract,
+                     request_id: request_data.id_ext_transaction },
+          response: { created_at: Time.parse(response_header.dig('timeStamp')) }
+        }
+      end
+
+      def response_service_data
+        b2b_response_hash.dig('serviceData')
+      end
+
+      def response_header
+        b2b_response_hash.dig('header')
+      end
+
+      def response_root_node
+        return response_service_data.dig(response_root_node_name) if response_service_data.keys.include?(response_root_node_name)
+
+        errors.add(:xml, "Cannot find `#{response_root_node_name}` in `serviceData` node.")
+        fail_on_structure_parsing
+      end
+
+      def b2b_response_hash
+        response_hash.dig('b2bSyncResponse') || response_hash.dig('b2bASyncResponse')
+      end
+
+      def request_data
+        b2b_request_hash = response_header.dig('b2bRequestHeader')
+        OpenStruct.new(id_ext_transaction: b2b_request_hash.dig('idExtTransaction').to_s,
+                       time_stamp: Time.parse(b2b_request_hash.dig('timeStamp')),
+                       id_contract: b2b_request_hash.dig('idContract').to_s)
+      end
+
+      def state_hash_from(hash)
+        state_hash = hash || { 'responseCode' => '999', 'responseText' => 'Unknown' }
+        state_hash = state_hash.first if state_hash.is_a?(Array) # more <doParcelStateResponse> elements
+
+        { code: state_hash['responseCode'].to_i, text: state_hash['responseText'].to_s}
+      end
+
+      def handle_parsing_error(error)
+        @result = { parser_error: error.message, xml: response_xml }
+        errors.add(:xml, "XML can not be parsed! Is it valid XML? #{error.class} > #{error.message}")
+        fail!
+      end
+
+      def handle_result_building_error(error)
+        @result = { result_builder_error: error.message + ' at line: ' + error.backtrace.first,
+                    response_hash: response_hash }
+        fail_on_structure_parsing
+      end
+
+      def fail_on_structure_parsing
+        errors.add(:xml, 'Parsed XML can not be converted to result hash. Is it correct response for this parser?')
+        fail!
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/response_parsers/get_parcel_state_parser.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module ResponseParsers
+    class GetParcelStateParser < BaseParser
+      def build_result
+        super
+        @result[:parcels] = parcels_data_hash
+      end
+
+      def parcels_data_hash
+        response_parcel_hashes.each_with_object({}) do |rp_hash, result|
+          result[rp_hash['idParcel']] = parcel_data_from(rp_hash)
+        end
+      end
+
+      def response_root_node_name
+        'getParcelStateResponse'
+      end
+
+      def response_parcel_hashes
+        return [] if response_root_node.nil?
+
+        [response_root_node.dig('parcel')].flatten.compact # to always get array of hash(es)
+      end
+
+      def parcel_data_from(rp_hash)
+        {
+          parcel_type: rp_hash['parcelType'].to_s,
+          weight_in_kg: rp_hash['weight'].nil? ? nil : rp_hash['weight'].to_f,  # hopefully it is in KG
+          cash_on_delivery: { amount: (rp_hash['amount'] || 0).to_f, currency_iso_code: rp_hash['currency'].to_s },
+          pieces: (rp_hash['quantityParcel'] || 1).to_i,
+          deposited_until: rp_hash['depositTo'].nil? ? nil : Date.parse(rp_hash['depositTo']),
+          deposited_for_days: rp_hash['timeDeposit'].nil? ? nil : rp_hash['timeDeposit'].to_i,
+          country_of_origin: rp_hash['countryOfOrigin'].to_s,
+          country_of_destination: rp_hash['countryOfDestination'].to_s,
+          states: states_array_from(rp_hash)
+        }
+      end
+
+      def states_array_from(rp_hash)
+        rp_states = [rp_hash.dig('states', 'state')].flatten.compact # to always get (empty?) array of hash(es)
+
+        rp_states.collect do |rp_state_hash|
+          { id: rp_state_hash['id'].to_s,
+            date: Date.parse(rp_state_hash['date']),
+            text: rp_state_hash['text'],
+            post_code: rp_state_hash['postCode'],
+            post_name: rp_state_hash['name'] }
+        end
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/response_parsers/get_parcels_printing_parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require "base64"
+
+module CzechPostB2bClient
+  module ResponseParsers
+    class GetParcelsPrintingParser < BaseParser
+      def build_result
+        super
+        @result[:response][:state] = state_hash_from(printing_response_header_result.dig('doPrintingStateResponse'))
+        @result[:printings] = { options: options_hash,
+                                pdf_content: pdf_content }
+      end
+
+      def options_hash
+        options_response = printing_response_header_result.dig('doPrintingHeader')
+        {
+          customer_id: options_response.dig('customerID'),
+          contract_number: options_response.dig('contractNumber'),
+          template_id: options_response.dig('idForm').to_i,
+          margin_in_mm: { top: options_response.dig('shiftVertical').to_i,
+                          left: options_response.dig('shiftHorizontal').to_i },
+          position_order: options_response.dig('position').to_i
+        }
+      end
+
+      def pdf_content
+        pdf_content_encoded = response_root_node.dig('doPrintingDataResult', 'file')
+        return nil if pdf_content_encoded.nil?
+
+        ::Base64.decode64(pdf_content_encoded)
+      end
+
+      def response_root_node_name
+        'getParcelsPrintingResponse'
+      end
+
+      def printing_response_header_result
+        response_root_node.dig('doPrintingHeaderResult')
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/response_parsers/get_result_parcels_parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module ResponseParsers
+    class GetResultParcelsParser < BaseParser
+      def build_result
+        super
+        @result[:response][:state] = state_hash_from(response_state_response)
+        @result[:parcels] = parcels_data_hash
+      end
+
+      def parcels_data_hash
+        response_parcel_hashes.each_with_object({}) do |rp_hash, result|
+          parcel_id = parcel_parcel_id_from(rp_hash)
+          result[parcel_id] = updated_result_value_for(result[parcel_id], rp_hash)
+        end
+      end
+
+      def response_root_node_name
+        'getResultParcelsResponse'
+      end
+
+      def response_state_response
+        response_root_node.dig('doParcelHeaderResult', 'doParcelStateResponse')
+      end
+
+      def response_parcel_hashes
+        [response_root_node.dig('doParcelParamResult')].flatten.compact # to always get array of hash(es)
+      end
+
+      def parcel_parcel_id_from(rp_hash)
+        rp_hash['recordNumber'].to_s
+      end
+
+      def parcel_data_from(rp_hash)
+        { parcel_code: rp_hash['parcelCode'],
+          states: [state_hash_from(rp_hash.dig('doParcelStateResponse'))] }
+      end
+
+      def updated_result_value_for(value, parcel_params_result_hash)
+        pd_hash=parcel_data_from(parcel_params_result_hash)
+
+        return pd_hash if value.nil?
+
+        # more doParcelParamsResult nodes for one parcel_id => probably errors
+        old_p_code = value[:parcel_code]
+        new_p_code = pd_hash[:parcel_code]
+
+        value[:states] = (value[:states] + pd_hash[:states]).sort { |a, b| a[:code] <=> b[:code] }
+        raise "Two different parcel_codes [#{old_p_code}, #{new_p_code}] for parcel_id:'#{parcel_id}'" if old_p_code != new_p_code
+
+        value
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/response_parsers/get_stats_parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module ResponseParsers
+    class GetStatsParser < BaseParser
+      def build_result
+        super
+        @result[:imports] = { requested: imports.all,
+                              with_errors: imports.err,
+                              successful: imports.ok,
+                              imported_parcels: imports.parcels }
+      end
+
+      def imports
+        imports_hash = response_root_node
+        OpenStruct.new(all: imports_hash.dig('importAll').to_i,
+                       err: imports_hash.dig('importErr').to_i,
+                       ok: imports_hash.dig('importOk').to_i,
+                       parcels: imports_hash.dig('parcels').to_i)
+      end
+
+      def response_root_node_name
+        'getStatsResponse'
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/response_parsers/send_parcels_parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module ResponseParsers
+    class SendParcelsParser < BaseParser
+      def build_result
+        super
+        @result[:async_result] = { transaction_id: response_header.dig('idTransaction'),
+                                   processing_end_expected_at: Time.parse(response_header.dig('timeStampProcessing')) } # it is NOT CORRECT! They return CET time value with UTC timezone
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'czech_post_b2b_client/services/orchestrator'
+require 'czech_post_b2b_client/services/communicator'
+require 'czech_post_b2b_client/services/api_caller'
+require 'czech_post_b2b_client/services/parcels_sender'
+require 'czech_post_b2b_client/services/parcels_send_process_updater'
+require 'czech_post_b2b_client/services/address_sheets_generator'
+require 'czech_post_b2b_client/services/parcels_submission_closer'
+require 'czech_post_b2b_client/services/delivering_inspector'
+require 'czech_post_b2b_client/services/time_period_statisticator'

data/lib/czech_post_b2b_client/services/address_sheets_generator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class AddressSheetsGenerator < CzechPostB2bClient::Services::Communicator
+      attr_reader :parcel_codes, :options
+
+      def initialize(parcel_codes:, options: {})
+        @parcel_codes = parcel_codes
+        @options = options
+      end
+
+      def steps
+        super + %i[check_for_state_errors]
+      end
+
+      private
+
+      def request_builder_args
+        { parcel_codes: parcel_codes, options: options }
+      end
+
+      def request_builder_class
+        CzechPostB2bClient::RequestBuilders::GetParcelsPrintingBuilder
+      end
+
+      def api_caller_class
+        CzechPostB2bClient::Services::ApiCaller
+      end
+
+      def response_parser_class
+        CzechPostB2bClient::ResponseParsers::GetParcelsPrintingParser
+      end
+
+      def endpoint_path
+        '/getParcelsPrinting'
+      end
+
+      def build_result_from(response_hash)
+        OpenStruct.new(pdf_content: response_hash.dig(:printings, :pdf_content),
+                       state_text: response_hash.dig(:response, :state, :text),
+                       state_code: response_hash.dig(:response, :state, :code))
+      end
+
+      def check_for_state_errors
+        return if result.state_code == CzechPostB2bClient::ResponseCodes::Ok.code
+
+        r_code = CzechPostB2bClient::ResponseCodes.new_by_code(result.state_code)
+        errors.add(:response_state, r_code.to_s)
+
+        fail! unless r_code.info?
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services/api_caller.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'net/http'
+
+module CzechPostB2bClient
+  module Services
+    class ApiCaller < SteppedService::Base
+      KNOWN_CONNECTION_ERRORS = [
+        Timeout::Error,
+        Errno::EINVAL,
+        Errno::ECONNRESET,
+        EOFError,
+        SocketError,
+        Net::ReadTimeout,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError
+      ].freeze
+
+      def initialize(endpoint_path:, xml:)
+        @endpoint_path = endpoint_path
+        @request_xml = xml
+      end
+
+      def steps
+        %i[call_api handle_response]
+      end
+
+      private
+
+      attr_accessor :request_xml, :response, :endpoint_path
+
+      def call_api
+        request = Net::HTTP::Post.new service_uri.request_uri, headers
+        request.body = request_xml
+        CzechPostB2bClient.logger.debug("CzechPost B2B REQUEST: #{request} to #{service_uri.request_uri} with body:\n#{request.body}")
+        begin
+          self.response = https_conn.request(request)
+        rescue *KNOWN_CONNECTION_ERRORS => e
+          handle_connection_error(e)
+        end
+      end
+
+      def handle_response
+        CzechPostB2bClient.logger.debug("CzechPost B2B RESPONSE: #{response} with body:\n#{response.body}")
+
+        @result = ::OpenStruct.new(code: response.code.to_i, xml: response.body)
+        return unless b2b_error?
+
+        errors.add(:b2b, b2b_error_text)
+        fail!
+      end
+
+      def https_conn
+        @https_conn ||= Net::HTTP.start(service_uri.host, service_uri.port, connection_options)
+      end
+
+      def service_uri
+        @service_uri ||= URI.parse(configuration.b2b_api_base_uri + endpoint_path)
+      end
+
+      def headers
+        { 'Content-Type': 'text/xml' }
+      end
+
+      def connection_options
+        {
+          use_ssl: true,
+          verify_mode: OpenSSL::SSL::VERIFY_PEER,
+          keep_alive_timeout: 30,
+          cert: OpenSSL::X509::Certificate.new(File.read(configuration.certificate_path)),
+          # cert_password: configuration.certificate_password,
+          key: OpenSSL::PKey::RSA.new(File.read(configuration.private_key_path), configuration.private_key_password),
+          cert_store: post_signum_ca_store
+        }
+      end
+
+      def configuration
+        CzechPostB2bClient.configuration
+      end
+
+      def post_signum_ca_store
+        store = OpenSSL::X509::Store.new
+        store.set_default_paths # Optional method that will auto-include the system CAs.
+
+        # store.add_cert(OpenSSL::X509::Certificate.new(File.read("/path/to/ca2.crt")))
+        store.add_file(File.join(CzechPostB2bClient.certs_path, 'postsignum_qca4_root.pem'))
+        store.add_file(File.join(CzechPostB2bClient.certs_path, 'postsignum_vca5_sub.pem'))
+        store
+      end
+
+      def b2b_error?
+        result&.xml&.include?('B2BFaultMessage')
+      end
+
+      def b2b_error_text
+        error_match = result.xml.match(%r{<(?:\w+\:)?errorCode>(\d+)</(?:\w+\:)?errorCode>}) # errorCode tag with stripped out namespace
+        return 'error code not found in XML' unless error_match
+
+        error_code = error_match[1].to_i
+        error = CzechPostB2bClient::B2BErrors.new_by_code(error_code)
+        return "error code [#{error_code}] is unknown" unless error
+
+        error.message
+      end
+
+      def handle_connection_error(error)
+        @result = OpenStruct.new(code: 500, xml: '')
+        errors.add(:connection, "#{error.class} > #{service_uri} - #{error}")
+        fail!
+      end
+    end
+  end
+end