recurly 2.17.11 → 4.18.0

data/lib/recurly/account.rb

@@ -1,189 +0,0 @@
-module Recurly
-  # Accounts are core to managing your customers inside of Recurly.
-  # The account object stores the entire Recurly history of your customer and acts as the entry point
-  # for working with a customer's billing information, subscription data, transactions, invoices and more.
-  #
-  # Recurly Documentation: https://dev.recurly.com/docs/account-object
-  class Account < Resource
-    # @macro [attach] scope
-    #   @scope class
-    #   @return [Pager<Account>] A pager that yields +$1+ accounts.
-    scope :active,         state: :active
-    scope :closed,         state: :closed
-    scope :subscriber,     state: :subscriber
-    scope :non_subscriber, state: :non_subscriber
-    scope :past_due,       state: :past_due
-
-    # @return [Pager<Adjustment>, []] A pager that yields Adjustments for persisted
-    has_many :adjustments
-
-    # @return [Pager<Invoice>, []] A pager that yields Invoices for persisted
-    has_many :invoices
-
-    # @return [Pager<Subscription>, []] A pager that yields Subscriptions for persisted
-    has_many :subscriptions
-
-    # @return [Pager<Transaction>, []] A pager that yields Transaction for persisted
-    has_many :transactions
-
-    # @return [Pager<Note>, []] A pager that yields Note for persisted
-    has_many :notes
-
-    # @return [Pager<Redemption>, []] A pager that yields Redemptions for persisted
-    has_many :redemptions
-
-    # @return [Pager<ShippingAddress>, [ShippingAddress], []] A pager that yields ShippingAddresses;
-    #   or a list of ShippingAddresses if set by the programmer
-    has_many :shipping_addresses, readonly: false
-
-    # @return [BillingInfo, nil]
-    has_one :billing_info, readonly: false
-
-    # @return [AccountBalance, nil]
-    has_one :account_balance, readonly: true
-
-    # @return [Account, nil]
-    belongs_to :parent_account, class_name: :Account
-
-    # @return [Pager<Account>, []] A pager that yields Account for persisted
-    has_many :child_accounts, class_name: :Account
-
-    # @return [Pager<CreditPayment>, []]
-    has_many :credit_payments, class_name: :CreditPayment, readonly: true
-
-    # @return [[CustomField], []]
-    has_many :custom_fields, class_name: :CustomField, readonly: false
-
-    # @return [AccountAcquisition, nil]
-    has_one :account_acquisition, class_name: :AccountAcquisition, readonly: false
-
-    # Get's the first redemption given a coupon code
-    # @deprecated Use #{redemptions} instead
-    # @param coupon_code [String] The coupon code for the redemption
-    def redemption(coupon_code)
-      redemptions.detect { |r| r.coupon_code == coupon_code }
-    end
-
-    define_attribute_methods %w(
-      account_code
-      parent_account_code
-      state
-      username
-      email
-      cc_emails
-      first_name
-      last_name
-      company_name
-      company
-      phone
-      accept_language
-      hosted_login_token
-      vat_number
-      address
-      tax_exempt
-      exemption_certificate
-      entity_use_code
-      created_at
-      updated_at
-      closed_at
-      vat_location_valid
-      has_live_subscription
-      has_active_subscription
-      has_future_subscription
-      has_canceled_subscription
-      has_past_due_invoice
-      has_paused_subscription
-      preferred_locale
-    )
-    alias to_param account_code
-
-    def company_name
-      super || company
-    end
-
-    # Creates an invoice from the pending charges on the account.
-    # Raises an error if it fails.
-    #
-    # @return [InvoiceCollection] A newly-created invoice.
-    # @raise [Invalid] Raised if the account cannot be invoiced.
-    def invoice!(attrs={})
-      InvoiceCollection.from_response API.post(invoices.uri, attrs.empty? ? nil : Invoice.to_xml(attrs))
-    rescue Recurly::API::UnprocessableEntity => e
-      raise Invalid, e.message
-    end
-
-    # Builds an invoice from the pending charges on the account but does not persist the invoice.
-    # Raises an error if it fails.
-    #
-    # @return [InvoiceCollection] The newly-built invoice that has not been persisted.
-    # @raise [Invalid] Raised if the account cannot be invoiced.
-    def build_invoice
-      InvoiceCollection.from_response API.post("#{invoices.uri}/preview")
-    rescue Recurly::API::UnprocessableEntity => e
-      raise Invalid, e.message
-    end
-
-    # Reopen an account.
-    #
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the account is already open), and may raise an exception if the
-    #   attempt fails.
-    def reopen
-      return false unless link? :reopen
-      reload follow_link :reopen
-      true
-    end
-
-    # Verify a cvv code for the account's billing info.
-    #
-    # @example
-    #   acct = Recurly::Account.find('benjamin-du-monde')
-    #   begin
-    #     # If successful, returned billing_info will contain
-    #     # updated billing info details.
-    #     billing_info = acct.verify_cvv!("504")
-    #   rescue Recurly::API::BadRequest => e
-    #     e.message # => "This credit card has too many cvv check attempts."
-    #   rescue Recurly::Transaction::Error => e
-    #     # this will be the errors coming back from gateway
-    #     e.transaction_error_code # => "fraud_security_code"
-    #     e.gateway_error_code # => "fraud"
-    #   rescue Recurly::Resource::Invalid => e
-    #     e.message # => "verification_value must be three digits"
-    #   end
-    #
-    # @param [String] verification_value The CVV code to check
-    # @return [BillingInfo] The updated billing info
-    # @raise [Recurly::Transaction::Error] A Transaction Error will be raised if the gateway declines
-    # the cvv code.
-    # @raise [API::BadRequest] A BadRequest error will be raised if you attempt to check too many times
-    # and are locked out.
-    # @raise [Resource::Invalid] An Invalid Error will be raised if you send an invalid request (such as
-    # a value that is not a propert verification number).
-    def verify_cvv!(verification_value)
-      bi = BillingInfo.new(verification_value: verification_value)
-      bi.uri = "#{path}/billing_info/verify_cvv"
-      bi.save!
-      bi
-    end
-
-    def changed_attributes
-      attrs = super
-      if address.respond_to?(:changed?) && address.changed?
-        attrs['address'] = address
-      end
-      if custom_fields.any?(&:changed?)
-        attrs['custom_fields'] = custom_fields.select(&:changed?)
-      end
-      attrs
-    end
-
-    private
-
-    def xml_keys
-      keys = super
-      keys << 'account_code' if account_code? && !account_code_changed?
-      keys.sort
-    end
-  end
-end

data/lib/recurly/account_acquisition.rb

@@ -1,19 +0,0 @@
-module Recurly
-  # Recurly Documentation: https://dev.recurly.com/docs/create-account-acquisition
-  class AccountAcquisition < Resource
-    # @return [Account]
-    belongs_to :account
-
-    define_attribute_methods %w(
-      cost_in_cents
-      currency
-      channel
-      subchannel
-      campaign
-    )
-
-    # Acquisitions are only writeable and readable through {Account} instances.
-    embedded!
-    private_class_method :find
-  end
-end

data/lib/recurly/account_balance.rb

@@ -1,21 +0,0 @@
-module Recurly
-  # The AccountBalance object contains some information about the account's balance.
-  # It exists to give us parity with the v1 API which used to include this information with
-  # the {Account}. You can get an account's balance by calling {Account#account_balance} on an account instance.
-  #
-  # Recurly Documentation: https://dev.recurly.com/docs/lookup-account-balance
-  class AccountBalance < Resource
-    # @return [Account, nil]
-    has_one :account, readonly: true
-
-    define_attribute_methods %w(
-      past_due
-      balance_in_cents
-    )
-
-    # This object does not represent a model on the server side
-    # so we do not need to expose these methods.
-    protected(*%w(save save!))
-    private_class_method(*%w(all find_each first paginate scoped where create! create))
-  end
-end

data/lib/recurly/add_on.rb

@@ -1,30 +0,0 @@
-module Recurly
-  class AddOn < Resource
-    # @return [Plan]
-    belongs_to :plan
-
-    define_attribute_methods %w(
-      add_on_code
-      name
-      accounting_code
-      default_quantity
-      unit_amount_in_cents
-      display_quantity_on_hosted_page
-      tax_code
-      add_on_type
-      measured_unit_id
-      optional
-      usage_type
-      usage_percentage
-      revenue_schedule_type
-      created_at
-      updated_at
-    )
-    alias to_param add_on_code
-    alias quantity default_quantity
-
-    # Add-ons are only writeable and readable through {Plan} instances.
-    embedded!
-    private_class_method :find
-  end
-end

data/lib/recurly/address.rb

@@ -1,25 +0,0 @@
-module Recurly
-  class Address < Resource
-    define_attribute_methods %w(
-      first_name
-      last_name
-      name_on_account
-      company
-      address1
-      address2
-      city
-      state
-      zip
-      country
-      phone
-      geo_code
-    )
-
-    # This ensures every attribute is rendered
-    # when updating. The Address object does not
-    # accept partial updates on the server
-    def xml_keys
-      attributes.keys
-    end
-  end
-end

data/lib/recurly/adjustment.rb

@@ -1,76 +0,0 @@
-module Recurly
-  # The history of your customer's Recurly account can be tracked through adjustments, made up of credits and charges.
-  #
-  # Recurly Documentation: https://dev.recurly.com/docs/adjustment-object
-  class Adjustment < Resource
-    # @macro [attach] scope
-    #   @scope class
-    #   @return [Pager<Adjustment>] a pager that yields +$1+.
-    scope :charges,  type:  'charge'
-    scope :credits,  type:  'credit'
-    scope :pending,  state: 'pending'
-    scope :invoiced, state: 'invoiced'
-
-    # @return [Account, nil]
-    belongs_to :account
-    # @return [Invoice, nil]
-    belongs_to :invoice
-    # @return [Subscription, nil]
-    belongs_to :subscription
-
-    # @return [Pager<Adjustment>, []]
-    has_many :credit_adjustments, class_name: :Adjustment, readonly: true
-
-    # @return [ShippingAddress, nil]
-    has_one :shipping_address, class_name: :ShippingAddress, readonly: false
-
-    define_attribute_methods %w(
-      uuid
-      state
-      description
-      accounting_code
-      origin
-      unit_amount_in_cents
-      quantity
-      discount_in_cents
-      total_in_cents
-      currency
-      product_code
-      start_date
-      end_date
-      created_at
-      updated_at
-      quantity_remaining
-      revenue_schedule_type
-      tax_in_cents
-      tax_type
-      tax_region
-      tax_rate
-      tax_exempt
-      tax_code
-      tax_details
-      tax_types
-      proration_rate
-      credit_reason_code
-      original_adjustment_uuid
-      shipping_address_id
-    )
-    alias to_param uuid
-
-    # @return ["charge", "credit", nil] The type of adjustment.
-    attr_reader :type
-
-    # Adjustments should be built through {Account} instances.
-    #
-    # @return [Adjustment] A new adjustment.
-    # @example
-    #   account.adjustments.new attributes
-    # @see Resource#initialize
-    def initialize(attributes = {})
-      super({ :currency => Recurly.default_currency }.merge attributes)
-    end
-
-    # Adjustments are only writeable through an {Account} instance.
-    embedded! true
-  end
-end

data/lib/recurly/api/errors.rb

@@ -1,208 +0,0 @@
-require 'cgi'
-
-module Recurly
-  class API
-    # The superclass to all errors that occur when making an API request.
-    class ResponseError < Error
-      attr_reader :request
-      attr_reader :response
-
-      def initialize request, response
-        @request, @response = request, response
-      end
-
-      def code
-        response.code.to_i if response
-      end
-
-      def to_s
-        if description
-          return CGI.unescapeHTML [description, details].compact.join(' ')
-        end
-
-        return super unless code
-        "%d %s (%s %s)" % [
-          code, http_error, request.method, API.base_uri + request.path
-        ]
-      end
-
-      def symbol
-        xml and xml.root and xml.text '/error/symbol'
-      end
-
-      def description
-        xml and xml.root and xml.text '/error/description'
-      end
-
-      def details
-        xml and xml.root and xml.text '/error/details'
-      end
-
-      private
-
-      def http_error
-        Helper.demodulize self.class.name.gsub(/([a-z])([A-Z])/, '\1 \2')
-      end
-
-      def xml
-        @xml ||= begin
-          XML.new(response.body) if response and response.body and not response.body.empty?
-        rescue Recurly::XML::ParseError
-          nil
-        end
-      end
-    end
-
-    # === 3xx Redirection
-    #
-    # Not an error, per se, but should result in one in the normal course of
-    # API interaction.
-    class Redirection < ResponseError
-    end
-
-    # === 304 Not Modified
-    #
-    # Catchably raised when a request is made with an ETag.
-    class NotModified < ResponseError
-    end
-
-    # === 4xx Client Error
-    #
-    # The superclass to all client errors (responses with status code 4xx).
-    class ClientError < ResponseError
-    end
-
-    # === 400 Bad Request
-    #
-    # The request was invalid or could not be understood by the server.
-    # Resubmitting the request will likely result in the same error.
-    class BadRequest < ClientError
-    end
-
-    # === 401 Unauthorized
-    #
-    # The API key is missing or invalid for the given request.
-    class Unauthorized < ClientError
-      def description
-        response.body.strip
-      end
-    end
-
-    # === 402 Payment Required
-    #
-    # Your Recurly account is in production mode but is not in good standing.
-    # Please pay any outstanding invoices.
-    class PaymentRequired < ClientError
-    end
-
-    # === 403 Forbidden
-    #
-    # The login is attempting to perform an action it does not have privileges
-    # to access. The login credentials are correct.
-    class Forbidden < ClientError
-    end
-
-    # === 404 Not Found
-    #
-    # The resource was not found. This may be returned if the given account
-    # code or subscription plan does not exist. The response body will explain
-    # which resource was not found.
-    class NotFound < ClientError
-    end
-
-    # === 405 Method Not Allowed
-    #
-    # A method was attempted where it is not allowed.
-    #
-    # If this is raised, there may be a bug with the client library or with
-    # the server. Please contact support@recurly.com or
-    # {file a bug}[https://github.com/recurly/recurly-client-ruby/issues].
-    class MethodNotAllowed < ClientError
-    end
-
-    # === 406 Not Acceptable
-    #
-    # The request content type was not acceptable.
-    #
-    # If this is raised, there may be a bug with the client library or with
-    # the server. Please contact support@recurly.com or
-    # {file a bug}[https://github.com/recurly/recurly-client-ruby/issues].
-    class NotAcceptable < ClientError
-    end
-
-    # === 412 Precondition Failed
-    #
-    # The request was unsuccessful because a condition was not met. For
-    # example, this message may be returned if you attempt to cancel a
-    # subscription for an account that has no subscription.
-    class PreconditionFailed < ClientError
-    end
-
-    # === 415 Unsupported Media Type
-    #
-    # The request body was not recognized as XML.
-    #
-    # If this is raised, there may be a bug with the client library or with
-    # the server. Please contact support@recurly.com or
-    # {file a bug}[https://github.com/recurly/recurly-client-ruby/issues].
-    class UnsupportedMediaType < ClientError
-    end
-
-    # === 422 Unprocessable Entity
-    #
-    # Could not process a POST or PUT request because the request is invalid.
-    # See the response body for more details.
-    class UnprocessableEntity < ClientError
-    end
-
-    # === 5xx Server Error
-    #
-    # The superclass to all server errors (responses with status code 5xx).
-    class ServerError < ResponseError
-    end
-
-    # === 500 Internal Server Error
-    #
-    # The server encountered an error while processing your request and failed.
-    class InternalServerError < ServerError
-    end
-
-    # === 502 Gateway Error
-    #
-    # The load balancer or web server had trouble connecting to the Recurly.
-    # Please try the request again.
-    class GatewayError < ServerError
-    end
-
-    # === 503 Service Unavailable
-    #
-    # The service is temporarily unavailable. Please try the request again.
-    class ServiceUnavailable < ServerError
-    end
-
-    # Error mapping by status code.
-    ERRORS = Hash.new { |hash, code|
-      unless hash.key? code
-        case code
-          when 400...500 then ClientError
-          when 500...600 then ServerError
-          else                ResponseError
-        end
-      end
-    }.update(
-      304 => NotModified,
-      400 => BadRequest,
-      401 => Unauthorized,
-      402 => PaymentRequired,
-      403 => Forbidden,
-      404 => NotFound,
-      406 => NotAcceptable,
-      412 => PreconditionFailed,
-      415 => UnsupportedMediaType,
-      422 => UnprocessableEntity,
-      500 => InternalServerError,
-      502 => GatewayError,
-      503 => ServiceUnavailable
-    ).freeze
-  end
-end

data/lib/recurly/api/net_http_adapter.rb

@@ -1,111 +0,0 @@
-require 'cgi'
-require 'net/https'
-
-module Recurly
-  class API
-    module Net
-      module HTTPAdapter
-        # A hash of Net::HTTP settings configured before the request.
-        #
-        # @return [Hash]
-        def net_http
-          @net_http ||= {}
-        end
-
-        # Used to store any Net::HTTP settings.
-        #
-        # @example
-        #   Recurly::API.net_http = {
-        #     :verify_mode => OpenSSL::SSL::VERIFY_PEER,
-        #     :ca_path     => "/etc/ssl/certs",
-        #     :ca_file     => "/opt/local/share/curl/curl-ca-bundle.crt"
-        #   }
-        attr_writer :net_http
-
-        private
-
-        METHODS = {
-          :head   => ::Net::HTTP::Head,
-          :get    => ::Net::HTTP::Get,
-          :post   => ::Net::HTTP::Post,
-          :put    => ::Net::HTTP::Put,
-          :delete => ::Net::HTTP::Delete
-        }
-
-        def request method, uri, options = {}
-          head = headers.dup
-          head.update options[:head] if options[:head]
-          head.delete_if { |_, value| value.nil? }
-          uri = base_uri + uri
-          if options[:params] && !options[:params].empty?
-            pairs = options[:params].map { |key, value|
-              "#{CGI.escape key.to_s}=#{CGI.escape value.to_s}"
-            }
-            uri += "?#{pairs.join '&'}"
-          end
-          self.validate_uri!(uri)
-          request = METHODS[method].new uri.request_uri, head
-          request.basic_auth(*[Recurly.api_key, nil].flatten[0, 2])
-          if options[:body]
-            request['Content-Type'] = content_type
-            request.body = options[:body]
-          end
-          if options[:etag]
-            request['If-None-Match'] = options[:etag]
-          end
-          if options[:format]
-            request['Accept'] = FORMATS[options[:format]]
-          end
-          if options[:locale]
-            request['Accept-Language'] = options[:locale]
-          end
-          http = ::Net::HTTP.new uri.host, uri.port
-          http.use_ssl = uri.scheme == 'https'
-          net_http.each_pair { |key, value| http.send "#{key}=", value }
-
-          if Recurly.logger
-            Recurly.log :info, "===> %s %s" % [request.method, uri]
-            headers = request.to_hash
-            headers['authorization'] &&= ['Basic [FILTERED]']
-            Recurly.log :debug, headers.inspect
-            if request.body && !request.body.empty?
-              Recurly.log :debug, XML.filter(request.body)
-            end
-            start_time = Time.now
-          end
-
-          response = http.start { http.request request }
-          code = response.code.to_i
-
-          if Recurly.logger
-            latency = (Time.now - start_time) * 1_000
-            level = case code
-              when 200...300 then :info
-              when 300...400 then :warn
-              when 400...500 then :error
-              else                :fatal
-            end
-            Recurly.log level, "<=== %d %s (%.1fms)" % [
-              code,
-              response.class.name[9, response.class.name.length].gsub(
-                /([a-z])([A-Z])/, '\1 \2'
-              ),
-              latency
-            ]
-            Recurly.log :debug, response.to_hash.inspect
-            Recurly.log :debug, response.body if response.body
-          end
-
-          case code
-            when 200...300 then response
-            else                raise ERRORS[code].new request, response
-          end
-        rescue Errno::ECONNREFUSED => e
-          raise Error, e.message
-        end
-      end
-    end
-
-    extend Net::HTTPAdapter
-  end
-end