deliveries 0.1.0

data/lib/deliveries/couriers/mondial_relay.rb

@@ -0,0 +1,189 @@
+require_relative 'mondial_relay/collection_points/search/format_response'
+require_relative 'mondial_relay/shipments/create'
+require_relative 'mondial_relay/shipments/create/defaults'
+require_relative 'mondial_relay/shipments/create/format_params'
+require_relative 'mondial_relay/shipments/trace'
+require_relative 'mondial_relay/shipments/trace/format_response'
+require_relative 'mondial_relay/pickups/create/format_params'
+require_relative 'mondial_relay/labels/generate'
+require_relative 'mondial_relay/status_codes'
+require_relative 'mondial_relay/address'
+require 'savon'
+
+module Deliveries
+  module Couriers
+    module MondialRelay
+      extend Courier
+
+      Config = Struct.new(
+        :mondial_relay_merchant,
+        :mondial_relay_key
+      )
+
+      WSDL_ENDPOINT = 'http://api.mondialrelay.com/Web_Services.asmx?WSDL'.freeze
+
+      module_function
+
+      def api_client
+        Savon.client wsdl: WSDL_ENDPOINT,
+                     logger: Deliveries.logger,
+                     log: Deliveries.debug
+      end
+
+      def get_collection_points(country:, postcode:)
+        # Build params needed by web service.
+        params = { 'Enseigne' => Deliveries::Couriers::MondialRelay.config(:mondial_relay_merchant),
+                   'Pays' => country, 'NumPointRelais' => '', 'Ville' => '',
+                   'CP' => postcode, 'Latitude' => '', 'Longitude' => '',
+                   'Taille' => '', 'Poids' => '', 'Action' => '',
+                   'DelaiEnvoi' => '0', 'RayonRecherche' => '', 'TypeActivite' => '', 'NACE' => '' }
+        # Calculate security parameters.
+        params['Security'] = calculate_security_param params
+
+        response = api_client.call :wsi3_point_relais_recherche, message: params
+        # If response returns OK stat code.
+        if (response_result = response.body[:wsi3_point_relais_recherche_response][:wsi3_point_relais_recherche_result]) &&
+           response_result[:stat] == '0'
+
+          collection_points = []
+          [response_result.dig(:points_relais, :point_relais_details)].flatten.compact.each do |point_params|
+            collection_point_params = CollectionPoints::Search::FormatResponse.new(response: point_params).execute
+            collection_points << Deliveries::CollectionPoint.new(collection_point_params)
+          end
+
+          collection_points
+        else
+          raise Deliveries::APIError.new(
+            StatusCodes.message_for(response_result[:stat].to_i),
+            response_result[:stat]
+          )
+        end
+      end
+
+      def get_collection_point(global_point_id:)
+        global_point = Deliveries::CollectionPoint.parse_global_point_id(global_point_id: global_point_id)
+
+        params = { 'Enseigne' => Deliveries::Couriers::MondialRelay.config(:mondial_relay_merchant),
+                   'Pays' => global_point.country, 'NumPointRelais' => global_point.point_id, 'Ville' => '',
+                   'CP' => '', 'Latitude' => '', 'Longitude' => '',
+                   'Taille' => '', 'Poids' => '', 'Action' => '',
+                   'DelaiEnvoi' => '0', 'RayonRecherche' => '', 'TypeActivite' => '', 'NACE' => '' }
+
+        # Calculate security parameters.
+        params['Security'] = calculate_security_param params
+
+        response = api_client.call :wsi3_point_relais_recherche, message: params
+
+        response_result = response.body.dig(:wsi3_point_relais_recherche_response,
+                                            :wsi3_point_relais_recherche_result)
+
+        point_relais_details = response_result.dig(:points_relais, :point_relais_details)
+
+        if response_result[:stat] == '0' && point_relais_details.present?
+          collection_point_params = CollectionPoints::Search::FormatResponse.new(response: point_relais_details).execute
+          Deliveries::CollectionPoint.new(collection_point_params)
+        else
+          raise Deliveries::APIError.new(
+            StatusCodes.message_for(response_result[:stat].to_i),
+            response_result[:stat]
+          )
+        end
+      end
+
+      def create_shipment(sender:, receiver:, parcels:, reference_code:, collection_point: nil, shipment_date: nil, remarks: nil, language: 'FR')
+        params = Shipments::Create::FormatParams.new(
+          sender: sender.courierize(:mondial_relay),
+          receiver: receiver.courierize(:mondial_relay),
+          parcels: parcels,
+          collection_point: collection_point,
+          reference_code: reference_code,
+          remarks: remarks,
+          language: language
+        ).execute
+
+        tracking_code, label_url = Shipments::Create.new(
+          params: params
+        ).execute.values_at(:tracking_code, :label_url)
+
+        Deliveries::Shipment.new(
+          courier_id: 'mondial_relay',
+          sender: sender,
+          receiver: receiver,
+          parcels: parcels,
+          reference_code: reference_code,
+          tracking_code: tracking_code,
+          shipment_date: shipment_date,
+          label: Label.new(url: label_url)
+        )
+      end
+
+      def create_pickup(sender:, receiver:, parcels:, reference_code:,
+                        pickup_date: nil, remarks: nil, language: 'FR')
+        params = Pickups::Create::FormatParams.new(
+          sender: sender.courierize(:mondial_relay),
+          receiver: receiver.courierize(:mondial_relay),
+          parcels: parcels,
+          reference_code: reference_code,
+          pickup_date: pickup_date,
+          remarks: remarks,
+          language: language
+        ).execute
+
+        tracking_code, label_url = Shipments::Create.new(
+          params: params
+        ).execute.values_at(:tracking_code, :label_url)
+
+        Deliveries::Pickup.new(
+          courier_id: 'mondial_relay',
+          sender: sender,
+          receiver: receiver,
+          parcels: parcels,
+          reference_code: reference_code,
+          tracking_code: tracking_code,
+          pickup_date: pickup_date,
+          label: Label.new(url: label_url)
+        )
+      end
+
+      def shipment_info(tracking_code:, language: 'FR')
+        response = Shipments::Trace.new(
+          tracking_code: tracking_code,
+          language: language
+        ).execute
+
+        tracking_info_params = Shipments::Trace::FormatResponse.new(response: response).execute
+
+        tracking_info_params = tracking_info_params.merge(tracking_code: tracking_code)
+        Deliveries::TrackingInfo.new(tracking_info_params)
+      end
+
+      def pickup_info(tracking_code:, language: 'FR')
+        shipment_info(tracking_code: tracking_code, language: language)
+      end
+
+      def get_label(tracking_code:, language: 'FR')
+        label_url = Labels::Generate.new(
+          tracking_codes: tracking_code,
+          language: language
+        ).execute
+
+        Deliveries::Label.new(url: label_url)
+      end
+
+      def get_labels(tracking_codes:, language: 'FR')
+        labels_url = Labels::Generate.new(
+          tracking_codes: tracking_codes,
+          language: language
+        ).execute
+
+        Deliveries::Labels.new(url: labels_url)
+      end
+
+      def calculate_security_param(params)
+        Digest::MD5.hexdigest(params.map do |_, v|
+                                v
+                              end.join + Deliveries::Couriers::MondialRelay.config(:mondial_relay_key)).upcase
+      end
+    end
+  end
+end

data/lib/deliveries/couriers/mondial_relay_dual/address.rb

@@ -0,0 +1,31 @@
+module Deliveries
+  module Couriers
+    module MondialRelayDual
+      class Address < Deliveries::Address
+        def name
+          I18n.transliterate(@name.to_s).gsub(%r{[^0-9A-Z_\-'., /]}i, '').upcase.truncate(30, omission: '')
+        end
+
+        def street
+          I18n.transliterate(@street.to_s).gsub(%r{[^0-9A-Z_\-'., /]}i, '').upcase.truncate(30, omission: '')
+        end
+
+        def city
+          I18n.transliterate(@city.to_s).gsub(/[^A-Z_\-' ]/i, '').upcase.truncate(30, omission: '')
+        end
+
+        def country
+          @country.to_s.upcase
+        end
+
+        def phone
+          format_international_phone
+        end
+
+        def email
+          format_email
+        end
+      end
+    end
+  end
+end

data/lib/deliveries/couriers/mondial_relay_dual/pickups/create/format_params.rb

@@ -0,0 +1,39 @@
+module Deliveries
+  module Couriers
+    module MondialRelayDual
+      module Pickups
+        class Create
+          class FormatParams < Shipments::Create::FormatParams
+            def initialize(sender:, receiver:, parcels:, reference_code:, remarks:, language:)
+              super(
+                sender: sender,
+                receiver: receiver,
+                parcels: parcels,
+                reference_code: reference_code,
+                remarks: remarks,
+                language: language,
+                collection_point: nil
+              )
+            end
+
+            private
+
+            def delivery_mode
+              {
+                mode: 'LCC',
+                location: ''
+              }
+            end
+
+            def collection_mode
+              {
+                mode: 'REL',
+                location: ''
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deliveries/couriers/mondial_relay_dual/shipments/create/format_params.rb

@@ -0,0 +1,101 @@
+module Deliveries
+  module Couriers
+    module MondialRelayDual
+      module Shipments
+        class Create
+          class FormatParams
+            attr_accessor :sender, :receiver, :parcels, :reference_code, :collection_point, :remarks, :language
+
+            def initialize(sender:, receiver:, parcels:, reference_code:, collection_point:, remarks:, language:)
+              self.sender = sender.courierize(:mondial_relay_dual)
+              self.receiver = receiver.courierize(:mondial_relay_dual)
+              self.parcels = parcels
+              self.reference_code = reference_code
+              self.collection_point = collection_point
+              self.remarks = remarks
+              self.language = language
+            end
+
+            def execute
+              {
+                culture: culture,
+                order_no: reference_code,
+                parcel_count: parcels.to_i,
+                delivery_mode: delivery_mode,
+                collection_mode: collection_mode,
+                deliver_instruction: remarks,
+                parcels: parcel_list,
+                sender: {
+                  streetname: sender.street,
+                  country_code: sender.country,
+                  post_code: sender.postcode,
+                  city: sender.city,
+                  address_add_1: sender.name,
+                  phone_no: sender.phone,
+                  email: sender.email
+                },
+                recipient: {
+                  streetname: receiver.street,
+                  country_code: receiver.country,
+                  post_code: receiver.postcode,
+                  city: receiver.city,
+                  address_add_1: receiver.name,
+                  phone_no: receiver.phone,
+                  email: receiver.email
+                }
+              }
+            end
+
+            private
+
+            def culture
+              case language.to_s.downcase
+              when 'es' then 'es-ES'
+              when 'de' then 'de-DE'
+              when 'en' then 'en-GB'
+              else 'fr-FR'
+              end
+            end
+
+            def delivery_mode
+              if collection_point
+                {
+                  mode: '24R',
+                  location: collection_point.point_id
+                }
+              else
+                home_delivery_mode = MondialRelayDual.config("countries.#{receiver.country.downcase}.home_delivery_mode") || 'HOM'
+                {
+                  mode: home_delivery_mode,
+                  location: ''
+                }
+              end
+            end
+
+            def collection_mode
+              {
+                mode: 'CCC',
+                location: ''
+              }
+            end
+
+            def parcel_list
+              list = []
+              parcels.times do
+                list << {
+                  content: 'Vêtements',
+                  weight: {
+                    value: '1000',
+                    unit: 'gr'
+                  }
+                }
+              end
+
+              list
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deliveries/couriers/mondial_relay_dual/shipments/create.rb

@@ -0,0 +1,133 @@
+require 'nokogiri'
+
+module Deliveries
+  module Couriers
+    module MondialRelayDual
+      module Shipments
+        class Create
+          attr_accessor :params
+
+          def initialize(params:)
+            self.params = params
+          end
+
+          def execute
+            builder = Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
+              xml.ShipmentCreationRequest('xmlns:xsi0' => 'http://www.w3.org/2001/XMLSchema-instance',
+                                          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema', 'xmlns' => 'http://www.example.org/Request') do
+                xml.Context do
+                  xml.Login Deliveries::Couriers::MondialRelayDual.config(:dual_carrier_login)
+                  xml.Password Deliveries::Couriers::MondialRelayDual.config(:dual_carrier_password)
+                  xml.CustomerId Deliveries::Couriers::MondialRelayDual.config(:dual_carrier_customer_id)
+                  xml.Culture params[:culture]
+                  xml.VersionAPI '1.0'
+                end
+
+                xml.OutputOptions do
+                  xml.OutputFormat '10x15'
+                  xml.OutputType 'PdfUrl'
+                end
+
+                xml.ShipmentsList do
+                  xml.Shipment do
+                    xml.OrderNo params[:order_no]
+                    xml.CustomerNo
+                    xml.ParcelCount params[:parcel_count]
+                    xml.DeliveryMode(Mode: params.dig(:delivery_mode, :mode),
+                                     Location: params.dig(:delivery_mode,
+                                                          :location))
+                    xml.CollectionMode(Mode: params.dig(:collection_mode, :mode),
+                                       Location: params.dig(:collection_mode,
+                                                            :location))
+                    xml.Parcels do
+                      params[:parcels].each do |parcel|
+                        xml.Parcel do
+                          xml.Content parcel[:content]
+                          xml.Weight(Value: parcel.dig(:weight, :value), Unit: parcel.dig(:weight, :unit))
+                        end
+                      end
+                    end
+                    xml.DeliveryInstruction params[:deliver_instruction]
+                    xml.Sender do
+                      xml.Address do
+                        xml.Title
+                        xml.Firstname
+                        xml.Lastname
+                        xml.Streetname params.dig(:sender, :streetname)
+                        xml.HouseNo
+                        xml.CountryCode params.dig(:sender, :country_code)
+                        xml.PostCode params.dig(:sender, :post_code)
+                        xml.City params.dig(:sender, :city)
+                        xml.AddressAdd1 params.dig(:sender, :address_add_1)
+                        xml.AddressAdd2
+                        xml.AddressAdd3
+                        xml.PhoneNo params.dig(:sender, :phone_no)
+                        xml.MobileNo
+                        xml.Email params.dig(:sender, :email)
+                      end
+                    end
+                    xml.Recipient do
+                      xml.Address do
+                        xml.Title
+                        xml.Firstname
+                        xml.Lastname
+                        xml.Streetname params.dig(:recipient, :streetname)
+                        xml.HouseNo
+                        xml.CountryCode params.dig(:recipient, :country_code)
+                        xml.PostCode params.dig(:recipient, :post_code)
+                        xml.City params.dig(:recipient, :city)
+                        xml.AddressAdd1 params.dig(:recipient, :address_add_1)
+                        xml.AddressAdd2
+                        xml.AddressAdd3
+                        xml.PhoneNo params.dig(:recipient, :phone_no)
+                        xml.MobileNo
+                        xml.Email params.dig(:recipient, :email)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            response = HTTParty.post(
+              api_endpoint,
+              body: builder.to_xml,
+              headers: { 'Content-Type': 'application/xml', Accept: 'application/xml' },
+              debug_output: Deliveries.debug ? Deliveries.logger : nil
+            )
+
+            xml_doc = Nokogiri::XML(response.body, &:strict)
+            xml_doc.remove_namespaces!
+
+            shipment_number = xml_doc.xpath('//ShipmentCreationResponse/ShipmentsList/Shipment/@ShipmentNumber').first&.content
+            pdf_url = xml_doc.xpath('//ShipmentCreationResponse/ShipmentsList/Shipment/LabelList/Label/Output').first&.content
+
+            unless shipment_number && pdf_url
+              error_node = xml_doc.xpath('//ShipmentCreationResponse/StatusList/Status').find do |n|
+                %w[Critical\ Error Error].include?(n[:Level])
+              end
+              raise Deliveries::APIError.new(error_node[:Message], error_node[:Code]) if error_node
+
+              raise Deliveries::ClientError, 'Cannot obtain error code from the API response'
+            end
+
+            {
+              tracking_code: shipment_number,
+              pdf_url: pdf_url
+            }
+          end
+
+          private
+
+          def api_endpoint
+            if MondialRelayDual.live?
+              MondialRelayDual::API_ENDPOINT_LIVE
+            else
+              MondialRelayDual::API_ENDPOINT_TEST
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deliveries/couriers/mondial_relay_dual.rb

@@ -0,0 +1,105 @@
+require_relative 'mondial_relay_dual/shipments/create'
+require_relative 'mondial_relay_dual/shipments/create/format_params'
+require_relative 'mondial_relay_dual/pickups/create/format_params'
+require_relative 'mondial_relay_dual/address'
+
+module Deliveries
+  module Couriers
+    module MondialRelayDual
+      extend Courier
+
+      Config = Struct.new(
+        :dual_carrier_login,
+        :dual_carrier_password,
+        :dual_carrier_customer_id,
+        :countries
+      )
+
+      API_ENDPOINT_LIVE = 'https://connect-api.mondialrelay.com/api/shipment'.freeze
+      API_ENDPOINT_TEST = 'https://connect-api-sandbox.mondialrelay.com/api/shipment'.freeze
+
+      module_function
+
+      def get_collection_points(country:, postcode:)
+        MondialRelay.get_collection_points(
+          country: country,
+          postcode: postcode
+        )
+      end
+
+      def get_collection_point(global_point_id:)
+        MondialRelay.get_collection_point(global_point_id: global_point_id)
+      end
+
+      def create_shipment(sender:, receiver:, parcels:, reference_code:, collection_point: nil, shipment_date: nil, remarks: nil, language: nil)
+        params = Shipments::Create::FormatParams.new(
+          sender: sender,
+          receiver: receiver,
+          parcels: parcels,
+          collection_point: collection_point,
+          reference_code: reference_code,
+          remarks: remarks,
+          language: language
+        ).execute
+
+        tracking_code, pdf_url = Shipments::Create.new(
+          params: params
+        ).execute.values_at(:tracking_code, :pdf_url)
+
+        Deliveries::Shipment.new(
+          courier_id: 'mondial_relay_dual',
+          sender: sender,
+          receiver: receiver,
+          parcels: parcels,
+          reference_code: reference_code,
+          tracking_code: tracking_code,
+          shipment_date: shipment_date,
+          label: Label.new(url: pdf_url)
+        )
+      end
+
+      def create_pickup(sender:, receiver:, parcels:, reference_code:,
+                        pickup_date: nil, remarks: nil, language: nil)
+        params = Pickups::Create::FormatParams.new(
+          sender: sender,
+          receiver: receiver,
+          parcels: parcels,
+          reference_code: reference_code,
+          remarks: remarks,
+          language: language
+        ).execute
+
+        tracking_code, pdf_url = Shipments::Create.new(
+          params: params
+        ).execute.values_at(:tracking_code, :pdf_url)
+
+        Deliveries::Pickup.new(
+          courier_id: 'mondial_relay_dual',
+          sender: sender,
+          receiver: receiver,
+          parcels: parcels,
+          reference_code: reference_code,
+          tracking_code: tracking_code,
+          pickup_date: pickup_date,
+          label: Label.new(url: pdf_url)
+        )
+      end
+
+      def shipment_info(tracking_code:, language: nil)
+        MondialRelay.shipment_info(tracking_code: tracking_code, language: language)
+      end
+
+      def pickup_info(tracking_code:, language: nil)
+        MondialRelay.pickup_info(tracking_code: tracking_code, language: language)
+      end
+
+      def get_label(**)
+        raise NotImplementedError, 'This courier does not support get_label operation'
+      end
+
+      def get_labels(**)
+        raise NotImplementedError, 'This courier does not support get_labels operation'
+      end
+    end
+  end
+end

data/lib/deliveries/couriers/spring/address.rb

@@ -0,0 +1,23 @@
+module Deliveries
+  module Couriers
+    module Spring
+      class Address < Deliveries::Address
+        def name
+          @name.to_s[0, 35]
+        end
+
+        def street
+          @street.to_s[0, 35]
+        end
+
+        def street2
+          @street.to_s[35, 35].to_s
+        end
+
+        def street3
+          @street.to_s[70, 35].to_s
+        end
+      end
+    end
+  end
+end

data/lib/deliveries/couriers/spring/labels/generate.rb

@@ -0,0 +1,33 @@
+module Deliveries
+  module Couriers
+    module Spring
+      module Labels
+        class Generate
+          attr_accessor :tracking_code
+
+          def initialize(tracking_code:)
+            self.tracking_code = tracking_code
+          end
+
+          def execute
+            params = {
+              Apikey: Deliveries::Couriers::Spring.config(:api_key),
+              Command: 'GetShipmentLabel',
+              Shipment: {
+                LabelFormat: 'PDF',
+                TrackingNumber: tracking_code
+              }
+            }
+
+            response = Deliveries::Couriers::Spring::Request.execute(params: params)
+
+            {
+              url: response[:Shipment][:CarrierTrackingUrl],
+              decoded_label: Base64.decode64(response[:Shipment][:LabelImage]).force_encoding('binary')
+            }
+          end
+        end
+      end
+    end
+  end
+end