canada_post_pws.rb

module ActiveShipping
  class CanadaPostPWS < Carrier
    @@name = "Canada Post PWS"

    SHIPPING_SERVICES = {
      "DOM.RP"        => "Regular Parcel",
      "DOM.EP"        => "Expedited Parcel",
      "DOM.XP"        => "Xpresspost",
      "DOM.XP.CERT"   => "Xpresspost Certified",
      "DOM.PC"        => "Priority",
      "DOM.LIB"       => "Library Books",

      "USA.EP"        => "Expedited Parcel USA",
      "USA.PW.ENV"    => "Priority Worldwide Envelope USA",
      "USA.PW.PAK"    => "Priority Worldwide pak USA",
      "USA.PW.PARCEL" => "Priority Worldwide Parcel USA",
      "USA.SP.AIR"    => "Small Packet USA Air",
      "USA.SP.SURF"   => "Small Packet USA Surface",
      "USA.XP"        => "Xpresspost USA",

      "INT.XP"        => "Xpresspost International",
      "INT.IP.AIR"    => "International Parcel Air",
      "INT.IP.SURF"   => "International Parcel Surface",
      "INT.PW.ENV"    => "Priority Worldwide Envelope Int'l",
      "INT.PW.PAK"    => "Priority Worldwide pak Int'l",
      "INT.PW.PARCEL" => "Priority Worldwide parcel Int'l",
      "INT.SP.AIR"    => "Small Packet International Air",
      "INT.SP.SURF"   => "Small Packet International Surface"
    }

    ENDPOINT = "https://soa-gw.canadapost.ca/"    # production

    SHIPMENT_MIMETYPE = "application/vnd.cpc.ncshipment+xml"
    RATE_MIMETYPE = "application/vnd.cpc.ship.rate+xml"
    TRACK_MIMETYPE = "application/vnd.cpc.track+xml"
    REGISTER_MIMETYPE = "application/vnd.cpc.registration+xml"

    LANGUAGE = {
      'en' => 'en-CA',
      'fr' => 'fr-CA'
    }

    SHIPPING_OPTIONS = [:d2po, :d2po_office_id, :cov, :cov_amount, :cod, :cod_amount, :cod_includes_shipping,
                        :cod_method_of_payment, :so, :dc, :dns, :pa18, :pa19, :hfp, :lad,
                        :rase, :rts, :aban]

    RATES_OPTIONS = [:cov, :cov_amount, :cod, :so, :dc, :dns, :pa18, :pa19, :hfp, :lad]

    MAX_WEIGHT = 30 # kg

    attr_accessor :language, :endpoint, :logger, :platform_id, :customer_number

    def initialize(options = {})
      @language = LANGUAGE[options[:language]] || LANGUAGE['en']
      @endpoint = options[:endpoint] || ENDPOINT
      @platform_id = options[:platform_id]
      @customer_number = options[:customer_number]
      super(options)
    end

    def requirements
      [:api_key, :secret]
    end

    def find_rates(origin, destination, line_items = [], options = {}, package = nil, services = [])
      url = endpoint + "rs/ship/price"
      request  = build_rates_request(origin, destination, line_items, options, package, services)
      response = ssl_post(url, request, headers(options, RATE_MIMETYPE, RATE_MIMETYPE))
      parse_rates_response(response, origin, destination)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      error_response(e.response.body, CPPWSRateResponse)
    end

    def find_tracking_info(pin, options = {})
      response = ssl_get(tracking_url(pin), headers(options, TRACK_MIMETYPE))
      parse_tracking_response(response)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      if e.response
        error_response(e.response.body, CPPWSTrackingResponse)
      else
        CPPWSTrackingResponse.new(false, e.message, {}, :carrier => @@name)
      end
    rescue InvalidPinFormatError
      CPPWSTrackingResponse.new(false, "Invalid Pin Format", {}, :carrier => @@name)
    end

    # line_items should be a list of PackageItem's
    def create_shipment(origin, destination, package, line_items = [], options = {})
      request_body = build_shipment_request(origin, destination, package, line_items, options)
      response = ssl_post(create_shipment_url(options), request_body, headers(options, SHIPMENT_MIMETYPE, SHIPMENT_MIMETYPE))
      parse_shipment_response(response)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      error_response(e.response.body, CPPWSShippingResponse)
    rescue MissingCustomerNumberError
      CPPWSShippingResponse.new(false, "Missing Customer Number", {}, :carrier => @@name)
    end

    def retrieve_shipment(shipping_id, options = {})
      response = ssl_post(shipment_url(shipping_id, options), nil, headers(options, SHIPMENT_MIMETYPE, SHIPMENT_MIMETYPE))
      parse_shipment_response(response)
    end

    def find_shipment_receipt(shipping_id, options = {})
      response = ssl_get(shipment_receipt_url(shipping_id, options), headers(options, SHIPMENT_MIMETYPE, SHIPMENT_MIMETYPE))
      parse_shipment_receipt_response(response)
    end

    def retrieve_shipping_label(shipping_response, options = {})
      raise MissingShippingNumberError unless shipping_response && shipping_response.shipping_id
      ssl_get(shipping_response.label_url, headers(options, "application/pdf"))
    end

    def register_merchant(options = {})
      url = endpoint + "ot/token"
      response = ssl_post(url, nil, headers({}, REGISTER_MIMETYPE, REGISTER_MIMETYPE).merge("Content-Length" => "0"))
      parse_register_token_response(response)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      error_response(e.response.body, CPPWSRegisterResponse)
    end

    def retrieve_merchant_details(options = {})
      raise MissingTokenIdError unless token_id = options[:token_id]
      url = endpoint + "ot/token/#{token_id}"
      response = ssl_get(url, headers({}, REGISTER_MIMETYPE, REGISTER_MIMETYPE))
      parse_merchant_details_response(response)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      error_response(e.response.body, CPPWSMerchantDetailsResponse)
    rescue Exception => e
      raise ResponseError.new(e.message)
    end

    def find_services(country = nil, options = {})
      response = ssl_get(services_url(country), headers(options, RATE_MIMETYPE))
      parse_services_response(response)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      error_response(e.response.body, CPPWSRateResponse)
    end

    def find_service_options(service_code, country, options = {})
      response = ssl_get(services_url(country, service_code), headers(options, RATE_MIMETYPE))
      parse_service_options_response(response)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      error_response(e.response.body, CPPWSRateResponse)
    end

    def find_option_details(option_code, options = {})
      url = endpoint + "rs/ship/option/#{option_code}"
      response = ssl_get(url, headers(options, RATE_MIMETYPE))
      parse_option_response(response)
    rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
      error_response(e.response.body, CPPWSRateResponse)
    end

    def maximum_weight
      Mass.new(MAX_WEIGHT, :kilograms)
    end

    def maximum_address_field_length
      # https://www.canadapost.ca/cpo/mc/business/productsservices/developers/services/shippingmanifest/createshipment.jsf
      44
    end

    # service discovery

    def parse_services_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      service_nodes = doc.xpath('services/service')
      service_nodes.inject({}) do |result, node|
        service_code = node.at("service-code").text
        service_name = node.at("service-name").text
        service_link = node.at("link").attributes['href'].value
        service_link_media_type = node.at("link").attributes['media-type'].value
        result[service_code] = {
          :name => service_name,
          :link => service_link,
          :link_media_type => service_link_media_type
        }
        result
      end
    end

    def parse_service_options_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!

      service_code = doc.root.at("service-code").text
      service_name = doc.root.at("service-name").text

      option_nodes = doc.root.xpath('options/option')
      options = option_nodes.map do |node|
        option = {
          :code => node.at("option-code").text,
          :name => node.at("option-name").text,
          :required => node.at("mandatory").text != "false",
          :qualifier_required => node.at("qualifier-required").text != "false",
        }
        option[:qualifier_max] = node.at("qualifier-max").text.to_i if node.at("qualifier-max")
        option
      end

      restrictions_node = doc.root.at('restrictions')
      dimensions_node = restrictions_node.at('dimensional-restrictions')
      restrictions = {
        :min_weight => restrictions_node.at("weight-restriction").attributes['min'].value.to_i,
        :max_weight => restrictions_node.at("weight-restriction").attributes['max'].value.to_i,
        :min_length => dimensions_node.at("length").attributes['min'].value.to_f,
        :max_length => dimensions_node.at("length").attributes['max'].value.to_f,
        :min_height => dimensions_node.at("height").attributes['min'].value.to_f,
        :max_height => dimensions_node.at("height").attributes['max'].value.to_f,
        :min_width => dimensions_node.at("width").attributes['min'].value.to_f,
        :max_width => dimensions_node.at("width").attributes['max'].value.to_f
      }

      {
        :service_code => service_code,
        :service_name => service_name,
        :options => options,
        :restrictions => restrictions
      }
    end

    def parse_option_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!

      conflicts = doc.root.xpath('conflicting-options/option-code').map(&:text)
      prereqs = doc.root.xpath('prerequisite-options/option-code').map(&:text)
      option = {
        :code => doc.root.at('option-code').text,
        :name => doc.root.at('option-name').text,
        :class => doc.root.at('option-class').text,
        :prints_on_label => doc.root.at('prints-on-label').text != "false",
        :qualifier_required => doc.root.at('qualifier-required').text != "false",
      }
      option[:conflicting_options] = conflicts if conflicts
      option[:prerequisite_options] = prereqs if prereqs

      option[:qualifier_max] = doc.root.at("qualifier-max").text.to_i if doc.root.at("qualifier-max")
      option
    end

    # rating

    def build_rates_request(origin, destination, line_items = [], options = {}, package = nil, services = [])
      line_items = Array(line_items)

      builder = Nokogiri::XML::Builder.new do |xml|
        xml.public_send('mailing-scenario', :xmlns => "http://www.canadapost.ca/ws/ship/rate") do
          customer_number_node(xml, options)
          contract_id_node(xml, options)
          quote_type_node(xml, options)
          expected_mailing_date_node(xml, shipping_date(options)) if options[:shipping_date]
          shipping_options_node(xml, RATES_OPTIONS, options)
          parcel_node(xml, line_items, package)
          origin_node(xml, origin)
          destination_node(xml, destination)
          services_node(xml, services) unless services.blank?
        end
      end
      builder.to_xml
    end

    def parse_rates_response(response, origin, destination)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      raise ActiveShipping::ResponseError, "No Quotes" unless doc.at('price-quotes')

      rates = doc.root.xpath('price-quote').map do |node|
        service_name  = node.at("service-name").text
        service_code  = node.at("service-code").text
        total_price   = node.at('price-details/due').text
        expected_date = expected_date_from_node(node)
        options = {
          :service_code   => service_code,
          :total_price    => total_price,
          :currency       => 'CAD',
          :delivery_range => [expected_date, expected_date]
        }
        RateEstimate.new(origin, destination, @@name, service_name, options)
      end
      CPPWSRateResponse.new(true, "", {}, :rates => rates)
    end

    # tracking

    def parse_tracking_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      raise ActiveShipping::ResponseError, "No Tracking" unless doc.at('tracking-detail')

      events = doc.root.xpath('significant-events/occurrence')

      shipment_events  = build_tracking_events(events)
      change_date      = doc.root.at('changed-expected-date').text
      expected_date    = doc.root.at('expected-delivery-date').text
      dest_postal_code = doc.root.at('destination-postal-id').text
      destination      = Location.new(:postal_code => dest_postal_code)
      origin           = Location.new(origin_hash_for(doc.root))
      options = {
        :carrier                 => @@name,
        :service_name            => doc.root.at('service-name').text,
        :expected_date           => expected_date.blank? ? nil : Date.parse(expected_date),
        :changed_date            => change_date.blank? ? nil : Date.parse(change_date),
        :change_reason           => doc.root.at('changed-expected-delivery-reason').text.strip,
        :destination_postal_code => doc.root.at('destination-postal-id').text,
        :shipment_events         => shipment_events,
        :tracking_number         => doc.root.at('pin').text,
        :origin                  => origin,
        :destination             => destination,
        :customer_number         => doc.root.at('mailed-by-customer-number').text
      }

      CPPWSTrackingResponse.new(true, "", {}, options)
    end

    def build_tracking_events(events)
      events.map do |event|
        date      = event.at('event-date').text
        time      = event.at('event-time').text
        zone      = event.at('event-time-zone').text
        timestamp = DateTime.parse("#{date} #{time} #{zone}")
        time      = Time.utc(timestamp.utc.year, timestamp.utc.month, timestamp.utc.day, timestamp.utc.hour, timestamp.utc.min, timestamp.utc.sec)
        message   = event.at('event-description').text
        location  = [event.at('event-retail-name'), event.at('event-site'), event.at('event-province')].
                      reject { |e| e.nil? || e.text.empty? }.join(", ")
        name      = event.at('event-identifier').text
        ShipmentEvent.new(name, time, location, message)
      end
    end

    # shipping

    # options
    # :service => 'DOM.EP'
    # :notification_email
    # :packing_instructions
    # :show_postage_rate
    # :cod, :cod_amount, :insurance, :insurance_amount, :signature_required, :pa18, :pa19, :hfp, :dns, :lad
    #
    def build_shipment_request(origin, destination, package, line_items = [], options = {})
      origin = sanitize_location(origin)
      destination = sanitize_location(destination)

      builder = Nokogiri::XML::Builder.new do |xml|
        xml.public_send('non-contract-shipment', :xmlns => "http://www.canadapost.ca/ws/ncshipment") do
          xml.public_send('delivery-spec') do
            shipment_service_code_node(xml, options)
            shipment_sender_node(xml, origin, options)
            shipment_destination_node(xml, destination, options)
            shipment_options_node(xml, options)
            shipment_parcel_node(xml, package)
            shipment_notification_node(xml, options)
            shipment_preferences_node(xml, options)
            references_node(xml, options)             # optional > user defined custom notes
            shipment_customs_node(xml, destination, line_items, options)
            # COD Remittance defaults to sender
          end
        end
      end
      builder.to_xml
    end

    def shipment_service_code_node(xml, options)
      xml.public_send('service-code', options[:service])
    end

    def shipment_sender_node(xml, location, options)
      xml.public_send('sender') do
        xml.public_send('name', location.name)
        xml.public_send('company', location.company) if location.company.present?
        xml.public_send('contact-phone', location.phone)
        xml.public_send('address-details') do
          xml.public_send('address-line-1', location.address1)
          xml.public_send('address-line-2', location.address2_and_3) unless location.address2_and_3.blank?
          xml.public_send('city', location.city)
          xml.public_send('prov-state', location.province)
          # xml.public_send('country-code', location.country_code)
          xml.public_send('postal-zip-code', location.postal_code)
        end
      end
    end

    def shipment_destination_node(xml, location, options)
      xml.public_send('destination') do
        xml.public_send('name', location.name)
        xml.public_send('company', location.company) if location.company.present?
        xml.public_send('client-voice-number', location.phone)
        xml.public_send('address-details') do
          xml.public_send('address-line-1', location.address1)
          xml.public_send('address-line-2', location.address2_and_3) unless location.address2_and_3.blank?
          xml.public_send('city', location.city)
          xml.public_send('prov-state', location.province) unless location.province.blank?
          xml.public_send('country-code', location.country_code)
          xml.public_send('postal-zip-code', location.postal_code)
        end
      end
    end

    def shipment_options_node(xml, options)
      shipping_options_node(xml, SHIPPING_OPTIONS, options)
    end

    def shipment_notification_node(xml, options)
      return unless options[:notification_email]
      xml.public_send('notification') do
        xml.public_send('email', options[:notification_email])
        xml.public_send('on-shipment', true)
        xml.public_send('on-exception', true)
        xml.public_send('on-delivery', true)
      end
    end

    def shipment_preferences_node(xml, options)
      xml.public_send('preferences') do
        xml.public_send('show-packing-instructions', options[:packing_instructions] || true)
        xml.public_send('show-postage-rate', options[:show_postage_rate] || false)
        xml.public_send('show-insured-value', true)
      end
    end

    def references_node(xml, options)
      # custom values
      # xml.public_send('references') do
      # end
    end

    def shipment_customs_node(xml, destination, line_items, options)
      return unless destination.country_code != 'CA'

      xml.public_send('customs') do
        currency = options[:currency] || "CAD"
        xml.public_send('currency', currency)
        xml.public_send('conversion-from-cad', options[:conversion_from_cad].to_s) if currency != 'CAD' && options[:conversion_from_cad]
        xml.public_send('reason-for-export', 'SOG') # SOG - Sale of Goods
        xml.public_send('other-reason', options[:customs_other_reason]) if options[:customs_reason_for_export] && options[:customs_other_reason]
        xml.public_send('additional-customs-info', options[:customs_addition_info]) if options[:customs_addition_info]
        xml.public_send('sku-list') do
          line_items.each do |line_item|
            kg = '%#2.3f' % [sanitize_weight_kg(line_item.kg)]
            xml.public_send('item') do
              xml.public_send('hs-tariff-code', line_item.hs_code) if line_item.hs_code && !line_item.hs_code.empty?
              xml.public_send('sku', line_item.sku) if line_item.sku && !line_item.sku.empty?
              xml.public_send('customs-description', line_item.name.slice(0, 44))
              xml.public_send('unit-weight', kg)
              xml.public_send('customs-value-per-unit', '%.2f' % sanitize_price_from_cents(line_item.value))
              xml.public_send('customs-number-of-units', line_item.quantity)
              xml.public_send('country-of-origin', line_item.options[:country_of_origin]) if line_item.options && line_item.options[:country_of_origin] && !line_item.options[:country_of_origin].empty?
              xml.public_send('province-of-origin', line_item.options[:province_of_origin]) if line_item.options && line_item.options[:province_of_origin] && !line_item.options[:province_of_origin].empty?
            end
          end
        end

      end
    end

    def shipment_parcel_node(xml, package, options = {})
      weight = sanitize_weight_kg(package.kilograms.to_f)
      xml.public_send('parcel-characteristics') do
        xml.public_send('weight', "%#2.3f" % weight)
        pkg_dim = package.cm
        if pkg_dim && !pkg_dim.select { |x| x != 0 }.empty?
          xml.public_send('dimensions') do
            xml.public_send('length', '%.1f' % ((pkg_dim[2] * 10).round / 10.0)) if pkg_dim.size >= 3
            xml.public_send('width', '%.1f' % ((pkg_dim[1] * 10).round / 10.0)) if pkg_dim.size >= 2
            xml.public_send('height', '%.1f' % ((pkg_dim[0] * 10).round / 10.0)) if pkg_dim.size >= 1
          end
          xml.public_send('document', false)
        else
          xml.public_send('document', true)
        end

        xml.public_send('mailing-tube', package.tube?)
        xml.public_send('unpackaged', package.unpackaged?)
      end
    end

    def parse_shipment_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      raise ActiveShipping::ResponseError, "No Shipping" unless doc.at('non-contract-shipment-info')
      options = {
        :shipping_id      => doc.root.at('shipment-id').text,
        :details_url      => doc.root.at_xpath("links/link[@rel='details']")['href'],
        :label_url        => doc.root.at_xpath("links/link[@rel='label']")['href'],
        :receipt_url      => doc.root.at_xpath("links/link[@rel='receipt']")['href'],
      }
      options[:tracking_number] = doc.root.at('tracking-pin').text if doc.root.at('tracking-pin')

      CPPWSShippingResponse.new(true, "", {}, options)
    end

    def parse_register_token_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      raise ActiveShipping::ResponseError, "No Registration Token" unless doc.at('token')
      options = {
        :token_id => doc.root.at('token-id').text
      }
      CPPWSRegisterResponse.new(true, "", {}, options)
    end

    def parse_merchant_details_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      raise "No Merchant Info" unless doc.at('merchant-info')
      raise "No Merchant Info" if doc.root.at('customer-number').blank?
      options = {
        :customer_number => doc.root.at('customer-number').text,
        :contract_number => doc.root.at('contract-number').text,
        :username => doc.root.at('merchant-username').text,
        :password => doc.root.at('merchant-password').text,
        :has_default_credit_card => doc.root.at('has-default-credit-card').text == 'true'
      }
      CPPWSMerchantDetailsResponse.new(true, "", {}, options)
    end

    def parse_shipment_receipt_response(response)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      root = doc.at('non-contract-shipment-receipt')
      cc_details_node = root.at('cc-receipt-details')
      service_standard_node = root.at('service-standard')
      receipt = {
        :final_shipping_point => root.at("final-shipping-point").text,
        :shipping_point_name => root.at("shipping-point-name").text,
        :service_code => root.at("service-code").text,
        :rated_weight => root.at("rated-weight").text.to_f,
        :base_amount => root.at("base-amount").text.to_f,
        :pre_tax_amount => root.at("pre-tax-amount").text.to_f,
        :gst_amount => root.at("gst-amount").text.to_f,
        :pst_amount => root.at("pst-amount").text.to_f,
        :hst_amount => root.at("hst-amount").text.to_f,
        :charge_amount => cc_details_node.at("charge-amount").text.to_f,
        :currency => cc_details_node.at("currency").text,
        :expected_transit_days => service_standard_node.at("expected-transit-time").text.to_i,
        :expected_delivery_date => service_standard_node.at("expected-delivery-date").text
      }
      option_nodes = root.xpath('priced-options/priced-option')

      receipt[:priced_options] = if option_nodes.length > 0
        option_nodes.inject({}) do |result, node|
          result[node.at("option-code").text] = node.at("option-price").text.to_f
          result
          end
      else
        {}
      end

      receipt
    end

    def error_response(response, response_klass)
      doc = Nokogiri.XML(response)
      doc.remove_namespaces!
      messages = doc.xpath('messages/message')
      message = messages.map { |m| m.at('description').text }.join(", ")
      code = messages.map { |m| m.at('code').text }.join(", ")
      response_klass.new(false, message, {}, :carrier => @@name, :code => code)
    end

    def log(msg)
      logger.debug(msg) if logger
    end

    private

    def tracking_url(pin)
      case pin.length
        when 12, 13, 16
          endpoint + "vis/track/pin/%s/detail" % pin
        when 15
          endpoint + "vis/track/dnc/%s/detail" % pin
        else
          raise InvalidPinFormatError
        end
    end

    def create_shipment_url(options)
      raise MissingCustomerNumberError unless customer_number = options[:customer_number]
      if @platform_id.present?
        endpoint + "rs/#{customer_number}-#{@platform_id}/ncshipment"
      else
        endpoint + "rs/#{customer_number}/ncshipment"
      end
    end

    def shipment_url(shipping_id, options = {})
      raise MissingCustomerNumberError unless customer_number = options[:customer_number]
      if @platform_id.present?
        endpoint + "rs/#{customer_number}-#{@platform_id}/ncshipment/#{shipping_id}"
      else
        endpoint + "rs/#{customer_number}/ncshipment/#{shipping_id}"
      end
    end

    def shipment_receipt_url(shipping_id, options = {})
      raise MissingCustomerNumberError unless customer_number = options[:customer_number]
      if @platform_id.present?
        endpoint + "rs/#{customer_number}-#{@platform_id}/ncshipment/#{shipping_id}/receipt"
      else
        endpoint + "rs/#{customer_number}/ncshipment/#{shipping_id}/receipt"
      end
    end

    def services_url(country = nil, service_code = nil)
      url = endpoint + "rs/ship/service"
      url += "/#{service_code}" if service_code
      url += "?country=#{country}" if country
      url
    end

    def customer_credentials_valid?(credentials)
      (credentials.keys & [:customer_api_key, :customer_secret]).any?
    end

    def encoded_authorization(customer_credentials = {})
      if customer_credentials_valid?(customer_credentials)
        "Basic %s" % Base64.encode64("#{customer_credentials[:customer_api_key]}:#{customer_credentials[:customer_secret]}")
      else
        "Basic %s" % Base64.encode64("#{@options[:api_key]}:#{@options[:secret]}")
      end
    end

    def headers(customer_credentials, accept = nil, content_type = nil)
      headers = {
        'Authorization'   => encoded_authorization(customer_credentials),
        'Accept-Language' => language
      }
      headers['Accept'] = accept if accept
      headers['Content-Type'] = content_type if content_type
      headers['Platform-ID'] = platform_id if platform_id && customer_credentials_valid?(customer_credentials)
      headers
    end

    def customer_number_node(xml, options)
      xml.public_send("customer-number", options[:customer_number] || customer_number)
    end

    def contract_id_node(xml, options)
      xml.public_send("contract-id", options[:contract_id]) if options[:contract_id]
    end

    def quote_type_node(xml, options)
      xml.public_send("quote-type", 'commercial')
    end

    def expected_mailing_date_node(xml, date_as_string)
      xml.public_send("expected-mailing-date", date_as_string)
    end

    def parcel_node(xml, line_items, package = nil, options = {})
      weight = sanitize_weight_kg(package && !package.kilograms.zero? ? package.kilograms.to_f : line_items.sum(&:kilograms).to_f)
      xml.public_send('parcel-characteristics') do
        xml.public_send('weight', "%#2.3f" % weight)
        if package
          pkg_dim = package.cm
          if pkg_dim && !pkg_dim.select { |x| x != 0 }.empty?
            xml.public_send('dimensions') do
              xml.public_send('length', '%.1f' % ((pkg_dim[2] * 10).round / 10.0)) if pkg_dim.size >= 3
              xml.public_send('width', '%.1f' % ((pkg_dim[1] * 10).round / 10.0)) if pkg_dim.size >= 2
              xml.public_send('height', '%.1f' % ((pkg_dim[0] * 10).round / 10.0)) if pkg_dim.size >= 1
            end
          end
        end
        xml.public_send('mailing-tube', line_items.any?(&:tube?))
        xml.public_send('oversized', true) if line_items.any?(&:oversized?)
        xml.public_send('unpackaged', line_items.any?(&:unpackaged?))
      end
    end

    def origin_node(xml, location)
      origin = sanitize_location(location)
      xml.public_send("origin-postal-code", origin.zip)
    end

    def destination_node(xml, location)
      destination = sanitize_location(location)
      case destination.country_code
        when 'CA'
          xml.public_send('destination') do
            xml.public_send('domestic') do
              xml.public_send('postal-code', destination.postal_code)
            end
          end

        when 'US'
          xml.public_send('destination') do
            xml.public_send('united-states') do
              xml.public_send('zip-code', destination.postal_code)
            end
          end

        else
          xml.public_send('destination') do
            xml.public_send('international') do
              xml.public_send('country-code', destination.country_code)
            end
          end
      end
    end

    def services_node(xml, services)
      xml.public_send('services') do
        services.each { |code| xml.public_send('service-code', code) }
      end
    end

    def shipping_options_node(xml, available_options, options = {})
      return if (options.symbolize_keys.keys & available_options).empty?
      xml.public_send('options') do

        if options[:cod] && options[:cod_amount]
          xml.public_send('option') do
            xml.public_send('option-code', 'COD')
            xml.public_send('option-amount', options[:cod_amount])
            xml.public_send('option-qualifier-1', options[:cod_includes_shipping]) unless options[:cod_includes_shipping].blank?
            xml.public_send('option-qualifier-2', options[:cod_method_of_payment]) unless options[:cod_method_of_payment].blank?
          end
        end

        if options[:cov]
          xml.public_send('option') do
            xml.public_send('option-code', 'COV')
            xml.public_send('option-amount', options[:cov_amount]) unless options[:cov_amount].blank?
          end
        end

        if options[:d2po]
          xml.public_send('option') do
            xml.public_send('option-code', 'D2PO')
            xml.public_send('option-qualifier-2'. options[:d2po_office_id]) unless options[:d2po_office_id].blank?
          end
        end

        [:so, :dc, :pa18, :pa19, :hfp, :dns, :lad, :rase, :rts, :aban].each do |code|
          if options[code]
            xml.public_send('option') do
              xml.public_send('option-code', code.to_s.upcase)
            end
          end
        end
      end
    end

    def expected_date_from_node(node)
      if service = node.at('service-standard/expected-delivery-date')
        expected_date = service.text
      else
        expected_date = nil
      end
      expected_date
    end

    def shipping_date(options)
      DateTime.strptime((options[:shipping_date] || Time.now).to_s, "%Y-%m-%d")
    end

    def sanitize_location(location)
      location_hash = location.is_a?(Location) ? location.to_hash : location
      location_hash = sanitize_zip(location_hash)
      Location.new(location_hash)
    end

    def sanitize_zip(hash)
      [:postal_code, :zip].each do |attr|
        hash[attr].gsub!(/\s+/, '') if hash[attr]
      end
      hash
    end

    def sanitize_weight_kg(kg)
      kg == 0 ? 0.001 : kg
    end

    def sanitize_price_from_cents(value)
      value == 0 ? 0.01 : value.round / 100.0
    end

    def origin_hash_for(root)
      occurrences = root.xpath('significant-events/occurrence')
      earliest = occurrences.sort_by { |occurrence| time_of_occurrence(occurrence) }.first

      {
        city: earliest.at('event-site').text,
        province: earliest.at('event-province').text,
        address_1: earliest.at('event-retail-location-id').text,
        country: 'Canada'
      }
    end

    def time_of_occurrence(occurrence)
      time = occurrence.at('event-time').text
      date = occurrence.at('event-date').text
      time_zone = occurrence.at('event-time-zone').text
      DateTime.parse "#{date} #{time} #{time_zone}"
    end
  end

  module CPPWSErrorResponse
    attr_accessor :error_code
    def handle_error(message, options)
      @error_code = options[:code]
    end
  end

  class CPPWSRateResponse < RateResponse
    include CPPWSErrorResponse

    def initialize(success, message, params = {}, options = {})
      handle_error(message, options)
      super
    end
  end

  class CPPWSTrackingResponse < TrackingResponse
    DELIVERED_EVENT_CODES = %w(1496 1498 1499 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438)
    include CPPWSErrorResponse

    attr_reader :service_name, :expected_date, :changed_date, :change_reason, :customer_number

    def initialize(success, message, params = {}, options = {})
      handle_error(message, options)
      super
      @service_name    = options[:service_name]
      @expected_date   = options[:expected_date]
      @changed_date    = options[:changed_date]
      @change_reason   = options[:change_reason]
      @customer_number = options[:customer_number]
    end

    def delivered?
      !delivered_event.nil?
    end

    def actual_delivery_time
      delivered_event.time if delivered?
    end

    private

    def delivered_event
      @delivered_event ||= @shipment_events.detect { |event| DELIVERED_EVENT_CODES.include? event.name }
    end
  end

  class CPPWSShippingResponse < ShippingResponse
    include CPPWSErrorResponse
    attr_reader :label_url, :details_url, :receipt_url
    def initialize(success, message, params = {}, options = {})
      handle_error(message, options)
      super
      @label_url      = options[:label_url]
      @details_url    = options[:details_url]
      @receipt_url    = options[:receipt_url]
    end
  end

  class CPPWSRegisterResponse < Response
    include CPPWSErrorResponse
    attr_reader :token_id
    def initialize(success, message, params = {}, options = {})
      handle_error(message, options)
      super
      @token_id = options[:token_id]
    end

    def redirect_url(customer_id, return_url)
      "http://www.canadapost.ca/cpotools/apps/drc/merchant?return-url=#{CGI.escape(return_url)}&token-id=#{token_id}&platform-id=#{customer_id}"
    end
  end

  class CPPWSMerchantDetailsResponse < Response
    include CPPWSErrorResponse
    attr_reader :customer_number, :contract_number, :username, :password, :has_default_credit_card
    def initialize(success, message, params = {}, options = {})
      handle_error(message, options)
      super
      @customer_number = options[:customer_number]
      @contract_number = options[:contract_number]
      @username = options[:username]
      @password = options[:password]
      @has_default_credit_card = options[:has_default_credit_card]
    end
  end

  class InvalidPinFormatError < StandardError; end
  class MissingCustomerNumberError < StandardError; end
  class MissingShippingNumberError < StandardError; end
  class MissingTokenIdError < StandardError; end
end