awesome_usps 0.5.0

data/lib/awesome_usps/location.rb

@@ -0,0 +1,97 @@
+module AwesomeUsps #:nodoc:
+  class Location
+
+    attr_reader :options,
+    :country,
+    :name,
+    :last_name,
+    :firm_name,
+    :zip5,
+    :zip4,
+    :state,
+    :city,
+    :address1,
+    :address2,
+    :address3,
+    :phone,
+    :facility_type,
+    :from_urbanization
+    #:fax,
+    #:address_type
+
+    alias_method :postal_code, :zip5
+    alias_method :postal, :postal_code
+    alias_method :zip, :postal
+    alias_method :province, :state
+    alias_method :territory, :province
+    alias_method :region, :province
+    alias_method :first_name, :name
+
+    def initialize(options = {})
+      @country = options[:country]
+      @name = options[:name] || options[:first_name]
+      @last_name= options[:last_name]
+      @firm_name = options[:firm_name]
+      @zip5 = options[:postal_code] || options[:postal] || options[:zip5]
+      @zip4 = options[:zip4]
+      @state = options[:province] || options[:state]
+      @city = options[:city]
+      @address1 = options[:address1]
+      @address2 = options[:address2]
+      @address3=options [:address3]
+      @phone = options[:phone]
+      @facility_type = options[:facility_type]
+      @from_urbanization =options[:from_urbanization]
+    end
+
+    def self.from(object, options={})
+      return object if object.is_a? FotoVerite::Location
+      attr_mappings = {
+        :name => [:name, :first_name],
+        #:country => [:country_code, :country],
+        :zip5 => [:postal_code, :zip5, :postal],
+        :zip4 => [:zip4],
+        :state => [ :province, :state],
+        :city => [:city],
+        :address1 => [:address1],
+        :address2 => [:address2],
+        :facility_type => [:facility_type]
+      }
+      attributes = {}
+      hash_access = begin
+        object[:some_symbol]
+        true
+      rescue
+        false
+      end
+      attr_mappings.each do |pair|
+        pair[1].each do |sym|
+          if value = (object[sym] if hash_access) || (object.send(sym) if object.respond_to?(sym) && (!hash_access || !Hash.public_instance_methods.include?(sym.to_s)))
+            attributes[pair[0]] = value
+            break
+          end
+        end
+      end
+      self.new(attributes.update(options))
+    end
+
+
+    def to_s
+      prettyprint.gsub(/\n/, ' ')
+    end
+
+    def prettyprint
+      chunks = []
+      chunks << [@name,@firm_name].reject {|e| e.blank?}.join("\n")
+      chunks << [@address1,@address2].reject {|e| e.blank?}.join("\n")
+      chunks << [@city,@state,@zip5].reject {|e| e.blank?}.join(', ')
+      chunks.reject {|e| e.blank?}.join("\n")
+    end
+
+    def inspect
+      string = prettyprint
+      string
+    end
+  end
+
+end

data/lib/awesome_usps/open_distrubute_priority.rb

@@ -0,0 +1,127 @@
+module  AwesomeUsps
+  module OpenDistrubutePriority
+
+    MAX_RETRIES = 3
+
+    LIVE_DOMAIN = 'secure.shippingapis.com'
+    LIVE_RESOURCE = '/ShippingAPI.dll'
+
+
+    API_CODES = {:open_distrubute_priority => "OpenDistributePriority",
+    :open_distribute_priority_certify => "OpenDistributePriorityCertify"}
+
+    def open_distrubute_priority_label(orgin, destination, package_weight_in_ounces,  mail_type, image_type, label_type=1, options={})
+      @package_weight_in_ounces = package_weight_in_ounces
+      @origin = origin
+      @destination = destination
+      @mail_type = mail_type
+      @image_type = image_type
+      @options =options
+      @api = "OpenDistributePriorityRequest"
+      request = open_distrubute_priority_xml
+      #YES THE API IS THAT STUPID THAT WE MUST PASS WHAT TYPE OF MIME TYPE!
+      commit_open_distrubute_priority_xml(:open_distrubute_priority, request, image_type, false)
+    end
+
+    def canned_open_distrubute_priority_label_test
+      @origin = Location.new( :name=> "John Smith",  :address2 => "6406 Ivy Lane",  :state => 'MD', :city => 'Greenbelt', :zip5 => '20770')
+      @destination =Location.new( :name=> "Fairfax Post Office",  :address2 =>"10660 Page Ave",  :state => 'VA', :city => 'Fairfax', :zip5 => "22030", :facility_type => "DDU")
+      @mail_type = "Letters"
+      @image_type = "PDF"
+      @package_weight_in_ounces = 1
+      @options = {:address_service => true, :permit_number => "21718", :permit_zip => "07204"}
+      @api = "OpenDistributePriorityCertifyRequest"
+      request= open_distrubute_priority_xml
+      commit_open_distrubute_priority_xml(:open_distribute_priority_certify, request, @image_type, true)
+    end
+
+    private
+    def open_distrubute_priority_xml
+      xm = Builder::XmlMarkup.new
+      xm.tag!("#{@api}", "USERID"=>"#{@username}") do
+        xm.PermitNumber(@options[:permit_number])
+        xm.PermitIssuingPOZip5(@options[:permit_zip])
+        xm.FromName(@origin.name)
+        xm.FromFirm(@origin.firm_name)
+        xm.FromAddress1(@origin.address1) #Used for an apartment or suite number. Yes the API is a bit fucked.
+        xm.FromAddress2(@origin.address2)
+        xm.FromCity(@origin.city)
+        xm.FromState(@origin.state)
+        xm.FromZip5(@origin.zip5)
+        xm.FromZip4(@origin.zip4)
+        xm.POZipCode(@options[:po_zip_code])
+        xm.ToFacilityName(@destination.name)
+        xm.ToFacilityAddress1(@destination.address1)
+        xm.ToFacilityAddress2(@destination.address2)
+        xm.ToFacilityCity(@destination.city)
+        xm.ToFacilityState(@destination.state)
+        xm.ToFacilityZip5(@destination.zip5)
+        xm.ToFacilityZip4(@destination.zip4)
+        xm.FacilityType(@destination.facility_type)
+        xm.MailClassEnclosed(@mail_type)
+        xm.MailClassOther(@options[:other])
+        xm.WeightInPounds("0")
+        xm.WeightInOunces(@package_weight_in_ounces)
+        xm.ImageType(@image_type)
+        xm.SeparateReceiptPage(@options[:seperate])
+        xm.LabelDate(@options[:label_date])
+        xm.AllowNonCleansedFacilityAddr("false")
+      end
+    end
+
+    def parse_open_distrubute_priority(xml, image_type)
+      if image_type == "TIF"
+        image_type = "image/tif"
+      else
+        image_type = "application/pdf"
+      end
+      parse = Hpricot.parse(xml)/:error
+      if parse != []
+        RAILS_DEFAULT_LOGGER.info "#{xml}"
+        return (Hpricot.parse(xml)/:description).inner_html
+      else
+        number = Hpricot.parse(xml)/:openDistributeprioritynumber
+        label = Hpricot.parse(xml)/:opendistributeprioritylabel
+        return {:image_type => image_type, :number => number.inner_html, :label => label.inner_html}
+      end
+    end
+
+    def commit_open_distrubute_priority_xml(action, request, image_type, test=false)
+      retries = MAX_RETRIES
+      begin
+        #If and when their testing resource works again this will be useful tertiary command
+        url = URI.parse("https://#{LIVE_DOMAIN}#{LIVE_RESOURCE}")
+        req = Net::HTTP::Post.new(url.path)
+        req.set_form_data({'API' => API_CODES[action], 'XML' => request})
+        response = Net::HTTP.new(url.host, 443)
+        response.use_ssl
+        response.open_timeout = 5
+        response.read_timeout = 5
+        response.use_ssl = true
+        response.start
+
+      rescue Timeout::Error
+        if retries > 0
+          retries -= 1
+          retry
+        else
+          RAILS_DEFAULT_LOGGER.warn "The connection to the remote server timed out"
+          return "We appoligize for the inconvience but our USPS service is busy at the moment. To retry please refresh the browser"
+        end
+      rescue SocketError
+        RAILS_DEFAULT_LOGGER.error "There is a socket error with USPS plugin"
+        return "We appoligize for the inconvience but there is a problem with our server. To retry please refresh the browser"
+      end
+
+      response = response.request(req)
+      case response
+      when Net::HTTPSuccess
+
+        parse_open_distrubute_priority(response.body, image_type)
+      else
+        RAILS_DEFAULT_LOGGER.warn("USPS plugin settings are wrong #{response.body}")
+        return "USPS plugin settings are wrong #{response.body}"
+      end
+    end
+  end
+end

data/lib/awesome_usps/package.rb

@@ -0,0 +1,132 @@
+module AwesomeUsps #:nodoc:
+  class Package
+    GRAMS_IN_AN_OUNCE = 28.3495231
+    OUNCES_IN_A_GRAM = 0.0352739619
+    INCHES_IN_A_CM = 0.393700787
+    CM_IN_AN_INCH = 2.54
+
+    cattr_accessor :default_options
+    attr_reader :options, :value, :currency
+
+    # Package.new(100, [10, 20, 30], :units => :metric)
+    def initialize(grams_or_ounces, dimensions, options = {})
+      options = @@default_options.update(options) if @@default_options
+      options.symbolize_keys!
+      @options = options
+
+      imperial = options[:units] == :imperial
+      dimensions = Array(dimensions)
+
+      @ounces,@grams = nil
+      if grams_or_ounces.nil?
+        @grams = @ounces = 0
+      elsif imperial
+        @ounces = grams_or_ounces
+      else
+        @grams = grams_or_ounces
+      end
+
+      @inches,@centimetres = nil
+      if dimensions.empty?
+        @inches = @centimetres = [0,0,0]
+      else
+        process_dimensions(dimensions,imperial)
+      end
+
+      @value = Package.cents_from(options[:value])
+      @currency = options[:currency] || (options[:value].currency if options[:value].respond_to?(:currency))
+      @cylinder = (options[:cylinder] || options[:tube]) ? true : false
+    end
+
+    def cylinder?
+      @cylinder
+    end
+    alias_method :tube?, :cylinder?
+
+    def ounces(options={})
+      case options[:type]
+      when *[nil,:actual]: @ounces ||= grams(options) * OUNCES_IN_A_GRAM
+      when *[:volumetric,:dimensional]: @volumetric_ounces ||= grams(options) * OUNCES_IN_A_GRAM
+      when :billable: @billable_ounces ||= [ounces,ounces(:type => :volumetric)].max
+      end
+    end
+    alias_method :oz, :ounces
+
+    def grams(options={})
+      case options[:type]
+      when *[nil,:actual]: @grams ||= ounces(options) * GRAMS_IN_AN_OUNCE
+      when *[:volumetric,:dimensional]: @volumetric_grams ||= centimetres(:box_volume) / 6.0
+      when :billable: [grams,grams(:type => :volumetric)].max
+      end
+    end
+    alias_method :g, :grams
+
+    def pounds(options={})
+      ounces(options) / 16.0
+    end
+    alias_method :lb, :pounds
+    alias_method :lbs, :pounds
+
+    def kilograms(options={})
+      grams(options) / 1000.0
+    end
+    alias_method :kg, :kilograms
+    alias_method :kgs, :kilograms
+
+    def inches(measurement=nil)
+      @inches ||= @centimetres.map {|cm| cm * INCHES_IN_A_CM}
+      measurement.nil? ? @inches : measure(measurement, @inches)
+    end
+    alias_method :in, :inches
+
+    def centimetres(measurement=nil)
+      @centimetres ||= @inches.map {|inches| inches * CM_IN_AN_INCH}
+      measurement.nil? ? @centimetres : measure(measurement, @centimetres)
+    end
+    alias_method :cm, :centimetres
+
+    def self.cents_from(money)
+      return nil if money.nil?
+      if money.respond_to?(:cents)
+        return money.cents
+      else
+        return case money
+      when Float
+        (money * 100).to_i
+      when String
+        money =~ /\./ ? (money.to_f * 100).to_i : money.to_i
+      else
+        money.to_i
+      end
+    end
+  end
+
+
+  private
+
+  def measure(measurement, ary)
+    case measurement
+    when Fixnum: ary[measurement]
+    when *[:x,:max,:length,:long]: ary[2]
+    when *[:y,:mid,:width,:wide]: ary[1]
+    when *[:z,:min,:height,:depth,:high,:deep]: ary[0]
+    when *[:girth,:around,:circumference]
+      self.cylinder? ? (Math::PI * (ary[0] + ary[1]) / 2) : (2 * ary[0]) + (2 * ary[1])
+    when :volume: self.cylinder? ? (Math::PI * (ary[0] + ary[1]) / 4)**2 * ary[2] : measure(:box_volume,ary)
+    when :box_volume: ary[0] * ary[1] * ary[2]
+    end
+  end
+
+  def process_dimensions(dimensions, imperial_units)
+    units = imperial_units ? 'inches' : 'centimetres'
+    self.instance_variable_set("@#{units}", dimensions.sort)
+    units_array = self.instance_variable_get("@#{units}")
+    # [1,2] => [1,1,2]
+    # [5] => [5,5,5]
+    # etc..
+    2.downto(units_array.length) do |n|
+      units_array.unshift(units_array[0])
+    end
+  end
+end
+end

data/lib/awesome_usps/service_standard.rb

@@ -0,0 +1,143 @@
+module AwesomeUsps
+  module ServiceStandard
+    MAX_RETRIES = 3
+
+    LIVE_DOMAIN = 'production.shippingapis.com'
+    LIVE_RESOURCE = '/ShippingAPI.dll'
+
+    TEST_DOMAIN ='testing.shippingapis.com'
+    TEST_RESOURCE = '/ShippingAPITest.dll'
+
+    API_CODES ={
+      :priority_mail => 'PriorityMail',
+      :standard => 'StandardB',
+      :express => 'ExpressMailCommitment'
+    }
+
+    # Takes your package tracking number and returns information for the USPS web API
+    def priority_mail_estimated_time(origin, destination)
+      @origin = orgin
+      @destination=destination
+      request = xml_for_estimated_time_for_delivery("PriorityMailRequest")
+      commit_service_standard_request(:priority_mail, request ,false)
+    end
+
+    def standard_mail_estimated_time(origin, destination)
+      @origin = orgin
+      @destination=destination
+      request = xml_for_estimated_time_for_delivery("StandardBRequest")
+      commit_service_standard_request(:standard, request ,false)
+    end
+
+    def express_mail_commitment(origin, destination, date=nil)
+      @origin = orgin
+      @destination=destination
+      @date = date
+      request = xml_for_estimated_time_for_delivery("ExpressMailCommitmentRequest")
+      commit_service_standard_request(:express, request ,false)
+    end
+
+    def canned_standard_mail_estimated_time_test
+      @origin =  Location.new(  :zip5 => '4')
+      @destination = Location.new( :zip5 => '4')
+      request = xml_for_estimated_time_for_delivery("PriorityMailRequest")
+      commit_service_standard_request(:priority_mail, request ,true)
+    end
+
+    def canned_priority_mail_estimated_time_test
+      @origin =  Location.new(  :zip5 => '4')
+      @destination = Location.new( :zip5 => '4')
+      request = xml_for_estimated_time_for_delivery("PriorityMailRequest")
+      commit_service_standard_request(:standard, request ,true)
+    end
+
+    def canned_express_mail_commitment_test
+      @origin= Location.new(  :zip5 =>'20770')
+      @destination=Location.new( :zip5 =>'11210')
+      @date = '05-Aug-2004'
+      request = xml_for_estimated_time_for_delivery("ExpressMailCommitmentRequest")
+      commit_service_standard_request(:express, request ,true)
+    end
+
+    # XML from a straight string.
+    # "<TrackFieldRequest USERID='#{@username}'><TrackID ID='#{@tracking_number}'></TrackID></TrackFieldRequest>"
+    def xml_for_estimated_time_for_delivery(type_of_request)
+      xm = Builder::XmlMarkup.new
+      xm.tag!(type_of_request, "USERID"=>"#{@username}") do
+        xm.OriginZIP(@origin.zip5)
+        xm.DestinationZIP(@destination.zip5)
+        xm.Date(@date) if type_of_request == "ExpressMailCommitmentRequest"
+      end
+    end
+
+    # Parses the XML into an array broken up by each event.
+    # Example of returned array
+    def parse_service(xml)
+      event_list = []
+      parse = Hpricot.parse(xml)/:error
+      if parse != []
+        RAILS_DEFAULT_LOGGER.info "#{xml}"
+        return (Hpricot.parse(xml)/:description).inner_html
+      else
+        return  parse = (Hpricot.parse(xml)/:days).inner_html
+      end
+    end
+
+    def parse_express(xml)
+      parse = Hpricot.parse(xml)/:error
+      if parse != []
+        RAILS_DEFAULT_LOGGER.info "#{xml}"
+        return (Hpricot.parse(xml)/:description).inner_html
+      else
+        i= 0
+        location_list = []
+        (Hpricot.parse(xml)/:location).each do |location|
+          i+=1
+          h = {}
+          location.children.each {|elem| h[elem.name.to_sym] = elem.inner_text unless elem.inner_text.blank?}
+          location_list << h
+        end
+        return   location_list
+      end
+    end
+
+    private
+    def commit_service_standard_request(action, request, test = false)
+      retries = MAX_RETRIES
+      begin
+        url = URI.parse(test ? "http://#{TEST_DOMAIN}#{TEST_RESOURCE}" : "http://#{LIVE_DOMAIN}#{LIVE_RESOURCE}")
+        req = Net::HTTP::Post.new(url.path)
+        req.set_form_data({'API' => API_CODES[action], 'XML' => request})
+        response = Net::HTTP.new(url.host, url.port)
+        response.open_timeout = 5
+        response.read_timeout = 5
+        response.start
+      rescue Timeout::Error
+        if retries > 0
+          retries -= 1
+          retry
+        else
+          RAILS_DEFAULT_LOGGER.warn "The connection to the remote server timed out"
+          return "We appoligize for the inconvience but our USPS service is busy at the moment. To retry please refresh the browser"
+
+        end
+      rescue SocketError
+        RAILS_DEFAULT_LOGGER.error "There is a socket error with USPS plugin"
+        return "We appoligize for the inconvience but there is a problem with our server. To retry please refresh the browser"
+      end
+
+      response = response.request(req)
+      case response
+      when Net::HTTPSuccess
+        if action == :express
+          parse_express(response.body)
+        else
+          parse_service(response.body)
+        end
+      else
+        RAILS_DEFAULT_LOGGER.warn("USPS plugin settings are wrong #{response}")
+      end
+    end
+
+  end
+end