speedy-bg 0.1.0

data/lib/speedy/resource_attributes.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Speedy
+  module ResourceAttributes
+    TYPE_CASTERS = {
+      integer: ->(value) { blank?(value) ? nil : value.to_i },
+      string: ->(value) { value&.to_s },
+      boolean: lambda do |value|
+        next nil if blank?(value)
+        next false if value == false || %w[false 0 no off].include?(value.to_s.downcase)
+
+        true
+      end,
+      float: ->(value) { blank?(value) ? nil : value.to_f }
+    }.freeze
+
+    def self.blank?(value)
+      value.nil? || (value.is_a?(String) && value.strip.empty?)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def fields
+        @fields ||= {}
+      end
+
+      def field(name, opts = {})
+        fields[name] = opts
+
+        define_method(name) do
+          cast_attribute(@attributes[name], opts[:type], opts[:of])
+        end
+
+        define_method("#{name}=") do |value|
+          @attributes[name] = cast_attribute(value, opts[:type], opts[:of])
+        end
+      end
+    end
+
+    private
+
+    def cast_attribute(value, type, collection_type = nil)
+      return cast_primitive(value, type) if TYPE_CASTERS.key?(type)
+      return cast_date(value) if type == :date
+      return cast_array(value, collection_type) if type == :array
+      return cast_hash(value, collection_type) if type == :hash
+
+      return cast_model(value, type) if type.is_a?(Class)
+
+      value
+    end
+
+    def cast_primitive(value, type)
+      TYPE_CASTERS.fetch(type).call(value)
+    end
+
+    def cast_model(value, type)
+      value.nil? || value.is_a?(type) ? value : type.new(value)
+    end
+
+    def cast_date(value)
+      return value if value.nil? || value.is_a?(Date)
+
+      Date.parse(value.to_s)
+    rescue StandardError
+      value
+    end
+
+    def cast_array(value, collection_type)
+      values = Array(value)
+      return values unless collection_type.is_a?(Class)
+
+      values.map { |item| item.is_a?(collection_type) ? item : collection_type.new(item) }
+    end
+
+    def cast_hash(value, value_type)
+      return value unless value.is_a?(Hash) && value_type.is_a?(Class)
+
+      value.transform_values { |item| item.is_a?(value_type) ? item : value_type.new(item) }
+    end
+  end
+end

data/lib/speedy/service_resource.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Speedy
+  class ServiceResource
+    attr_reader :client
+
+    class << self
+      def resource_path(value = nil)
+        return @resource_path unless value
+
+        @resource_path = value
+      end
+    end
+
+    ERROR_MESSAGES = {
+      400 => 'Your request was malformed.',
+      401 => 'You did not supply valid authentication credentials.',
+      403 => 'You are not allowed to perform that action.',
+      404 => 'No results were found for your request.',
+      429 => 'Your request exceeded the API rate limit.',
+      500 => 'We were unable to perform the request due to server-side problems.',
+      503 => 'The Speedy API is currently unavailable.'
+    }.freeze
+
+    def initialize(client: Speedy::Client.instance)
+      message = 'Speedy::Client is not configured. Call `Speedy::Client.configure` first.'
+
+      @client = client || raise(message)
+    end
+
+    def resource_url
+      self.class.resource_path
+    end
+
+    private
+
+    def get(url = nil, params: {}, headers: {})
+      response_for(with_transport_errors { client.connection.get(url_for(url), params, headers) })
+    end
+
+    def post(url = nil, body: nil, headers: {})
+      response_for(with_transport_errors { client.connection.post(url_for(url), request_body(body), headers) })
+    end
+
+    def delete(url = nil, params: {}, headers: {})
+      response_for(with_transport_errors { client.connection.delete(url_for(url), params, headers) })
+    end
+
+    def with_transport_errors
+      yield
+    rescue Faraday::TimeoutError => e
+      raise TimeoutError, 'Speedy API request timed out.', cause: e
+    rescue Faraday::ConnectionFailed => e
+      raise ConnectionError, 'Could not connect to the Speedy API.', cause: e
+    rescue Faraday::SSLError => e
+      raise SSLError, 'Speedy API TLS connection failed.', cause: e
+    end
+
+    def url_for(url)
+      [resource_url, url].compact.reject(&:empty?).join('/')
+    end
+
+    def request_body(body)
+      client.credentials.merge(body || {})
+    end
+
+    def response_for(response)
+      error = error_from(response.body)
+      raise Error.new(error: error, status: response.status) if error && !successful_response?(response)
+
+      error_message = ERROR_MESSAGES[response.status]
+      raise Error.new(error_message, status: response.status) if error_message
+      raise Error.new(status: response.status) unless successful_response?(response)
+
+      response
+    end
+
+    def collection(response, model)
+      model.collection(response.body)
+    end
+
+    def resource(response, model, key: nil)
+      model.build(response.body, key: key)
+    end
+
+    def error_from(body)
+      Speedy::Models::Error.build_from(body)
+    end
+
+    def successful_response?(response)
+      response.status.to_i.between?(200, 299)
+    end
+  end
+end

data/lib/speedy/services/calculation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Speedy
+  module Services
+    class Calculation < Speedy::ServiceResource
+      resource_path 'calculate'
+
+      # POST `/calculate`
+      def calculate(recipient:, service:, content:, payment:, sender: nil, **options)
+        response = post(body: {
+          sender: sender,
+          recipient: recipient,
+          service: service,
+          content: content,
+          payment: payment
+        }.merge(options).compact)
+
+        collection(response, Speedy::Models::Calculation::CalculationResult)
+      end
+    end
+  end
+end

data/lib/speedy/services/clients.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Speedy
+  module Services
+    class Clients < Speedy::ServiceResource
+      resource_path 'client'
+
+      def get(id)
+        response = post(id.to_s)
+        resource(response, Speedy::Models::Clients::Client, key: :client)
+      end
+
+      def own_id
+        response = post
+        response.body[:client_id] || response.body['client_id'] || response.body['clientId']
+      end
+
+      def contract_clients
+        response = post('contract')
+        collection(response, Speedy::Models::Clients::Client)
+      end
+
+      def create_contact(**attributes)
+        response = post('contact', body: attributes.compact)
+
+        response.body[:client_id] || response.body['client_id'] || response.body['clientId']
+      end
+
+      def contact_by_external_id(id:, secret_key:)
+        response = post("contact/external/#{id}", body: { secret_key: secret_key })
+        resource(response, Speedy::Models::Clients::Client, key: :client)
+      end
+
+      def contract_info
+        response = post('contract/info')
+        resource(response, Speedy::Models::Clients::ContractInfo)
+      end
+    end
+  end
+end

data/lib/speedy/services/courier_services.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Speedy
+  module Services
+    class CourierServices < Speedy::ServiceResource
+      resource_path 'services'
+
+      # POST `/services`
+      def all(date: nil)
+        response = post(body: { date: date }.compact)
+
+        collection(response, Speedy::Models::Services::CourierService)
+      end
+
+      # POST `/services/destination`
+      def for_destination(sender:, recipient:, date: nil)
+        response = post('destination', body: {
+          date: date, sender: sender, recipient: recipient
+        }.compact)
+
+        collection(response, Speedy::Models::Services::ExtendedCourierService)
+      end
+    end
+  end
+end

data/lib/speedy/services/location/block.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class Block < Speedy::ServiceResource
+        resource_path 'location/block'
+
+        # POST `/location/block`
+        def find(site_id:, name: nil)
+          response = post(body: { site_id: site_id, name: name }.compact)
+
+          collection(response, Speedy::Models::Location::Block)
+        end
+
+        # POST `/location/block/csv/{countryId}`
+        def all(country_id:)
+          response = post("csv/#{country_id}")
+          rows = CSV.parse(response.body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'siteId'
+
+            %i[site_id name name_en].zip(row).to_h
+          end
+
+          Speedy::Models::Location::Block.collection(rows)
+        end
+      end
+    end
+  end
+end

data/lib/speedy/services/location/complex.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class Complex < Speedy::ServiceResource
+        resource_path 'location/complex'
+
+        # POST `/location/complex/{id}`
+        def get(id)
+          response = post(id.to_s)
+
+          resource(response, Speedy::Models::Location::Complex, key: :complex)
+        end
+
+        # POST `/location/complex`
+        def find(site_id:, name: nil, type: nil)
+          response = post(body: { site_id: site_id, name: name, type: type }.compact)
+
+          collection(response, Speedy::Models::Location::Complex)
+        end
+
+        # POST `/location/complex/csv/{countryId}`
+        def all(country_id:)
+          response = post("csv/#{country_id}")
+          rows = CSV.parse(response.body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'id'
+
+            %i[id site_id type type_en name name_en actual_id].zip(row).to_h
+          end
+
+          Speedy::Models::Location::Complex.collection(rows)
+        end
+      end
+    end
+  end
+end

data/lib/speedy/services/location/country.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class Country < Speedy::ServiceResource
+        resource_path 'location/country'
+
+        # POST `/location/country`
+        def find(name: nil, iso_alpha2: nil, iso_alpha3: nil)
+          response = post(body: {
+            name: name, iso_alpha2: iso_alpha2, iso_alpha3: iso_alpha3
+          }.compact)
+
+          collection(response, Speedy::Models::Location::Country)
+        end
+
+        # POST `/location/country/{id}`
+        def get(id)
+          response = post(id.to_s)
+
+          resource(response, Speedy::Models::Location::Country, key: :country)
+        end
+
+        # POST `/location/country/csv`
+        def all
+          response = post('csv')
+          Speedy::Models::Location::Country.collection(csv_countries(response.body))
+        end
+
+        CSV_FIELDS = %i[
+          id name name_en iso_alpha2 iso_alpha3 post_code_formats require_state address_type
+          currency_code default_office_id street_types street_types_en complex_types
+          complex_types_en site_nomen
+        ].freeze
+
+        private
+
+        def csv_countries(body)
+          CSV.parse(body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'id'
+
+            country_attributes(row)
+          end
+        end
+
+        def country_attributes(row)
+          attributes = CSV_FIELDS.zip(row).to_h
+          attributes[:post_code_formats] = csv_list(attributes[:post_code_formats])
+          %i[street complex].each do |kind|
+            attributes[:"#{kind}_types"] = nomenclature(
+              attributes.delete(:"#{kind}_types"), attributes.delete(:"#{kind}_types_en")
+            )
+          end
+          attributes
+        end
+
+        def csv_list(value)
+          value.to_s.split(',').map(&:strip).reject(&:empty?)
+        end
+
+        def nomenclature(names, english_names)
+          csv_list(names).zip(csv_list(english_names)).map { |name, name_en| { name: name, name_en: name_en } }
+        end
+      end
+    end
+  end
+end

data/lib/speedy/services/location/office.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Speedy
+  module Services
+    module Location
+      class Office < Speedy::ServiceResource
+        include Speedy::Services::Location
+
+        resource_path 'location/office'
+
+        # POST `/location/office`
+        def find(country_id: nil, site_id: nil, site_name: nil, name: nil, limit: nil)
+          response = post(body: {
+            country_id: country_id,
+            site_id: site_id,
+            site_name: site_name,
+            name: name,
+            limit: limit
+          }.compact)
+
+          collection(response, Speedy::Models::Location::Office)
+        end
+
+        # POST `/location/office/{id}`
+        def get(id)
+          response = post(id.to_s)
+
+          resource(response, Speedy::Models::Location::GetOfficeResponse)
+        end
+
+        # POST `/location/office/nearest-offices`
+        def nearest(address:, distance: nil, limit: nil, office_type: nil, office_features: nil)
+          response = post('nearest-offices', body: {
+            address: address,
+            distance: distance,
+            limit: limit,
+            office_type: office_type,
+            office_features: office_features
+          }.compact)
+
+          collection(response, Speedy::Models::Location::OfficeResult)
+        end
+
+        alias find_offices find
+        alias get_office get
+        alias nearest_offices nearest
+      end
+    end
+  end
+end

data/lib/speedy/services/location/point_of_interest.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class PointOfInterest < Speedy::ServiceResource
+        resource_path 'location/poi'
+
+        # POST `/location/poi/{id}`
+        def get(id)
+          response = post(id.to_s)
+
+          resource(response, Speedy::Models::Location::PointOfInterest, key: :poi)
+        end
+
+        # POST `/location/poi`
+        def find(site_id:, name: nil)
+          response = post(body: { site_id: site_id, name: name }.compact)
+
+          collection(response, Speedy::Models::Location::PointOfInterest)
+        end
+
+        # POST `/location/poi/csv/{countryId}`
+        def all(country_id:)
+          response = post("csv/#{country_id}")
+          rows = CSV.parse(response.body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'id'
+
+            %i[id site_id name name_en address address_en x y type type_en].zip(row).to_h
+          end
+
+          Speedy::Models::Location::PointOfInterest.collection(rows)
+        end
+      end
+    end
+  end
+end

data/lib/speedy/services/location/postcode.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class Postcode < Speedy::ServiceResource
+        resource_path 'location/postcode'
+
+        # POST `/location/postcode/csv/{countryId}`
+        def all(country_id:)
+          response = post("csv/#{country_id}")
+          rows = CSV.parse(response.body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'postcode'
+
+            %i[postcode site_id].zip(row).to_h
+          end
+
+          Speedy::Models::Location::Postcode.collection(rows)
+        end
+      end
+    end
+  end
+end

data/lib/speedy/services/location/site.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class Site < Speedy::ServiceResource
+        include Speedy::Services::Location
+
+        resource_path 'location/site'
+
+        # POST `/location/site`
+        def find(country_id: nil, name: nil, post_code: nil, type: nil, municipality: nil, region: nil)
+          response = post(body: {
+            country_id: country_id,
+            name: name,
+            post_code: post_code,
+            type: type,
+            municipality: municipality,
+            region: region
+          }.compact)
+
+          collection(response, Speedy::Models::Location::Site)
+        end
+
+        # POST `/location/site/{id}`
+        def get(id)
+          response = post(id.to_s)
+
+          resource(response, Speedy::Models::Location::GetSiteResponse)
+        end
+
+        # POST `/location/site/csv/{countryId}`
+        def all(country_id:)
+          response = post("csv/#{country_id}")
+
+          Speedy::Models::Location::Site.collection(csv_sites(response.body))
+        end
+
+        alias find_sites find
+        alias get_site get
+
+        CSV_FIELDS = %i[
+          id
+          country_id
+          main_site_id
+          type
+          type_en
+          name
+          name_en
+          municipality
+          municipality_en
+          region
+          region_en
+          post_code
+          address_nomenclature
+          x
+          y
+          serving_days
+          serving_office_id
+          serving_hub_office_id
+        ].freeze
+
+        private
+
+        def csv_sites(body)
+          CSV.parse(body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'id'
+
+            CSV_FIELDS.zip(row).to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/speedy/services/location/state.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class State < Speedy::ServiceResource
+        include Speedy::Services::Location
+
+        resource_path 'location/state'
+
+        # POST `/location/state/{id}`
+        def get(id)
+          response = post(id.to_s)
+
+          resource(response, Speedy::Models::Location::State, key: :state)
+        end
+
+        # POST `/location/state`
+        def find(country_id: nil, name: nil)
+          response = post(body: {
+            country_id: country_id,
+            name: name
+          }.compact)
+
+          collection(response, Speedy::Models::Location::State)
+        end
+
+        # POST `/location/state/csv/{countryId}`
+        def all(country_id:)
+          response = post("csv/#{country_id}")
+          rows = CSV.parse(response.body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'id'
+
+            %i[id name name_en state_alpha country_id].zip(row).to_h
+          end
+
+          Speedy::Models::Location::State.collection(rows)
+        end
+
+        alias get_all_states all
+      end
+    end
+  end
+end

data/lib/speedy/services/location/street.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Speedy
+  module Services
+    module Location
+      class Street < Speedy::ServiceResource
+        resource_path 'location/street'
+
+        # POST `/location/street`
+        def find(site_id:, name: nil, type: nil)
+          response = post(body: { site_id: site_id, name: name, type: type }.compact)
+
+          collection(response, Speedy::Models::Location::Street)
+        end
+
+        # POST `/location/street/{id}`
+        def get(id)
+          response = post(id.to_s)
+
+          resource(response, Speedy::Models::Location::Street, key: :street)
+        end
+
+        # POST `/location/street/csv/{countryId}`
+        def all(country_id:)
+          response = post("csv/#{country_id}")
+          rows = CSV.parse(response.body.to_s).filter_map do |row|
+            next if row.compact.empty? || row.first.to_s == 'id'
+
+            %i[id site_id type type_en name name_en actual_id].zip(row).to_h
+          end
+
+          Speedy::Models::Location::Street.collection(rows)
+        end
+      end
+    end
+  end
+end