czech_post_b2b_client 1.0.0

data/lib/czech_post_b2b_client/services/communicator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class Communicator < CzechPostB2bClient::Services::Orchestrator
+      def steps
+        %i[build_request call_api process_response]
+      end
+
+      private
+
+      attr_accessor :request_xml, :response_xml, :response_hash
+
+      def build_request
+        self.request_xml = result_of_subservice(request_builder: request_builder_args)
+      end
+
+      def call_api
+        self.response_xml = result_of_subservice(api_caller: { endpoint_path: endpoint_path, xml: request_xml }).xml
+      end
+
+      def process_response
+        self.response_hash = result_of_subservice(response_parser: { xml: response_xml })
+        @result = build_result_from(response_hash) unless response_hash.nil?
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services/delivering_inspector.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class DeliveringInspector < CzechPostB2bClient::Services::Communicator
+      attr_reader :parcel_codes
+
+      def initialize(parcel_codes:)
+        @parcel_codes = parcel_codes
+      end
+
+      private
+
+      def request_builder_args
+        { parcel_codes: parcel_codes }
+      end
+
+      def request_builder_class
+        CzechPostB2bClient::RequestBuilders::GetParcelStateBuilder
+      end
+
+      def api_caller_class
+        CzechPostB2bClient::Services::ApiCaller
+      end
+
+      def response_parser_class
+        CzechPostB2bClient::ResponseParsers::GetParcelStateParser
+      end
+
+      def endpoint_path
+        '/getParcelState'
+      end
+
+      def build_result_from(response_hash)
+        puts("RESPONSE_HASH: #{response_hash}")
+        result_hash = {}
+        response_hash[:parcels].each_pair do |parcel_code, delivering_hash|
+          result_hash[parcel_code] = {
+              deposited_until: delivering_hash[:deposited_until],
+              deposited_for_days: delivering_hash[:deposited_for_days],
+              current_state: delivering_hash[:states].last,
+              all_states: delivering_hash[:states]
+          }
+        end
+        puts("RESULT_HASH: #{result_hash}")
+        result_hash
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services/orchestrator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class Orchestrator < SteppedService::Base
+
+      private
+
+      def result_of_subservice(service_hash)
+        service_name = service_hash.keys.first
+        service_class = send("#{service_name}_class")
+        service = service_class.call(service_hash.values.first)
+
+        if service.failed?
+          errors.add_from_hash(Hash[service_name, service.errors.full_messages])
+          fail!
+        end
+
+        service.result
+      end
+
+      def configuration
+        CzechPostB2bClient.configuration
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services/parcels_send_process_updater.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class ParcelsSendProcessUpdater < CzechPostB2bClient::Services::Communicator
+      attr_reader :transaction_id
+
+      def initialize(transaction_id:)
+        @transaction_id = transaction_id
+      end
+
+      def steps
+        super + %i[check_for_state_errors]
+      end
+
+      private
+
+      def request_builder_args
+        { transaction_id: transaction_id }
+      end
+
+      def request_builder_class
+        CzechPostB2bClient::RequestBuilders::GetResultParcelsBuilder
+      end
+
+      def api_caller_class
+        CzechPostB2bClient::Services::ApiCaller
+      end
+
+      def response_parser_class
+        CzechPostB2bClient::ResponseParsers::GetResultParcelsParser
+      end
+
+      def endpoint_path
+        '/getResultParcels'
+      end
+
+      def build_result_from(response_hash)
+        OpenStruct.new(parcels_hash: response_hash[:parcels],
+                       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)
+
+        collect_parcel_errors
+
+        fail! unless r_code.info?
+      end
+
+      def collect_parcel_errors
+        result.parcels_hash.each_pair do |parcel_id, parcel_hash|
+          add_errors_for_failed_states(parcel_id, parcel_hash[:states])
+        end
+      end
+
+      def add_errors_for_failed_states(parcel_id, response_states)
+        response_states.each do |response_state|
+          response_code = response_state[:code]
+          next if  response_code == CzechPostB2bClient::ResponseCodes::Ok.code
+
+          errors.add(:parcels, "Parcel[#{parcel_id}] => #{CzechPostB2bClient::ResponseCodes.new_by_code(response_code)}")
+        end
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services/parcels_sender.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class ParcelsSender < CzechPostB2bClient::Services::Communicator
+      attr_reader :sending_data, :parcels
+
+      def initialize(sending_data:, parcels:)
+        @sending_data = sending_data
+        @parcels = parcels
+      end
+
+      private
+
+      def request_builder_args
+        { common_data: common_data, parcels: parcels }
+      end
+
+      def request_builder_class
+        CzechPostB2bClient::RequestBuilders::SendParcelsBuilder
+      end
+
+      def api_caller_class
+        CzechPostB2bClient::Services::ApiCaller
+      end
+
+      def response_parser_class
+        CzechPostB2bClient::ResponseParsers::SendParcelsParser
+      end
+
+      def common_data
+        data_from_config.merge(sending_data)
+      end
+
+      def data_from_config
+        {
+          contract_id: configuration.contract_id,
+          customer_id: configuration.customer_id,
+          sending_post_office_code: configuration.sending_post_office_code
+        }
+      end
+
+      def endpoint_path
+        '/sendParcels'
+      end
+
+      def build_result_from(response_hash)
+        OpenStruct.new(transaction_id: response_hash.dig(:async_result, :transaction_id),
+                       processing_end_expected_at: response_hash.dig(:async_result, :processing_end_expected_at))
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services/parcels_submission_closer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class ParcelsSubmissionCloser < CzechPostB2bClient::Services::ParcelsSender
+      attr_reader :sending_data
+
+      def initialize(sending_data:)
+        @sending_data = sending_data
+      end
+
+      private
+
+      def request_builder_args
+        { common_data: common_closing_data, parcels: [] }
+      end
+
+      def common_closing_data
+        common_data.merge(close_requests_batch: true)
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/services/time_period_statisticator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  module Services
+    class TimePeriodStatisticator < CzechPostB2bClient::Services::Communicator
+      attr_reader :from_date, :to_date
+
+      def initialize(from_date:, to_date:)
+        @from_date =from_date
+        @to_date = to_date
+      end
+
+      private
+
+      def request_builder_args
+        { from_date: from_date, to_date: to_date }
+      end
+
+      def request_builder_class
+        CzechPostB2bClient::RequestBuilders::GetStatsBuilder
+      end
+
+      def api_caller_class
+        CzechPostB2bClient::Services::ApiCaller
+      end
+
+      def response_parser_class
+        CzechPostB2bClient::ResponseParsers::GetStatsParser
+      end
+
+      def endpoint_path
+        '/getStats'
+      end
+
+      def build_result_from(response_hash)
+        imports = response_hash[:imports]
+        OpenStruct.new(requests: OpenStruct.new(total: imports[:requested],
+                                                with_errors: imports[:with_errors],
+                                                successful: imports[:successful]),
+                       imported_parcels: imports[:imported_parcels])
+      end
+    end
+  end
+end

data/lib/czech_post_b2b_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CzechPostB2bClient
+  VERSION = '1.0.0'
+end

data/lib/stepped_service.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'stepped_service/errors'
+require 'stepped_service/base'

data/lib/stepped_service/base.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# Service class based on steps chain (see #steps), which can be successfull even with errors.
+# If execution of step is successful, next step will be executed.
+# Step can be marked as failed by calling #fail!. That will stop executing steps chain and return as #failed?.
+# During processing, #errors can be added, but they will not stop the execution.
+#
+# Example usage
+#
+#    class TeaMaker < SteppedService::Base
+#      attr_reader :tea_type, :bags_into_kettle
+#      def initialize(tea_type:, bags_into_kettle:)
+#        @tea_type = tea_type
+#        @bags_into_kettle = bags_into_kettle
+#      end
+#
+#      def steps
+#        %i[get_water_into_kettle
+#          make_it_boil
+#          put_tea_bags_into_kettle
+#          wait_3mins
+#          pour_tea_into_cups
+#          add_sugar_to_caps]
+#      end
+#
+#      private
+#
+#      attr_accessor :teabags, :kettle, :cups
+#
+#      def get_water_into_kettle
+#        self.kettle = find_kettle
+#        unless kettle
+#          errors.add(:kettle, "There is no kettle in kitchen!")
+#          fail!
+#        end
+#        fill_water_into(kettle)
+#      end
+#
+#      def make_it_boil
+#        ...
+#      end
+#
+#      def put_tea_bags_into_kettle
+#        self.teabags = get_teabags(tea_type, bags_into_kettle)
+#        if teabags.empty?
+#          errors.add(:teabags, "There is no #{bags_into_kettle} #{tea_type} tea teabags in storage,  using fruit tea teabags.")
+#          self.teabags = get_teabags(:fruit, bags_into_kettle)
+#          if teabags.empty?
+#            errors.add(:teabags, "There is no #{bags_into_kettle} fruit tea teabags in storage either!")
+#            fail!
+#          end
+#        end
+#        insert(teabags, to: kettle)
+#      end
+#
+#      ...
+#
+#      def add_sugar_to_caps # last step should fill @result
+#         cups.each{ |c| c.insert(sugar_cube) }
+#         @result = cups
+#      end
+#    end
+#
+# calling
+#    teamaker = TeaMaker.call(:black, 2)
+# will return instance of with:
+# - if there is no kettle :
+#     teamaker.failure? # => true
+#     teamaker.result # => nil
+#     teamaker.errors[:kettle] # => ["There is no kettle in kitchen!"]
+# - if there is no black tea but fruit was found:
+#     teamaker.success? # => true
+#     teamaker.result # => _cups with fruit tea_
+#     teamaker.errors[:teabags] # => ["There is no 2 :black tea teabags in storage, using fruit tea teabags."]
+# - if there is no black or fruit tea:
+#     teamaker.success? # => false
+#     teamaker.result # => nil
+#     teamaker.errors[:teabags] # => ["There is no 2 :black tea teabags in storage, using fruit tea teabags.",
+#                                     "There is no 2 fruit tea teabags in storage either!"]
+# - if all goes well:
+#     teamaker.success? # => true
+#     teamaker.result # => _cups with black tea_
+#     teamaker.errors # => {}
+module SteppedService
+  class Base
+    attr_reader :result
+
+    def self.call(*args, **keyword_args)
+      new(*args, **keyword_args).call
+    end
+
+    # You can override it, to not use steps
+    def call
+      @finished = false
+      @failed = false
+
+      steps.each do |step|
+        send(step)
+        return self if finished? || failed?
+      end
+      finish!
+      self
+    end
+
+    def steps
+      %i[need to be implemented]
+    end
+
+    def finished?
+      finished == true
+    end
+
+    def success?
+      !failure?
+    end
+
+    def failure?
+      failed == true
+    end
+    alias failed? failure?
+
+    def errors
+      # use with errors.add(:network, e.message)
+      @errors ||= Errors.new
+    end
+
+    private
+
+    attr_accessor :finished, :failed
+
+    def finish!
+      self.finished = true
+    end
+
+    def fail!
+      self.failed = true
+    end
+  end
+end